FINAL FIX: Resolve session state initialization error

app.py

@@ -14,7 +14,7 @@ st.set_page_config(
     layout="wide"
 )
 
-# Initialize session state
+# Initialize session state FIRST - before any other code
 if 'processed_data' not in st.session_state:
     st.session_state.processed_data = None
 if 'email_generator' not in st.session_state:
@@ -28,357 +28,395 @@ def init_database():
     cursor.execute('''
         CREATE TABLE IF NOT EXISTS scraped_data (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT,
-            email TEXT,
-            company TEXT,
+            linkedin_url TEXT UNIQUE,
+            company_name TEXT,
+            description TEXT,
+            industry TEXT,
+            website TEXT,
+            scraped_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS generated_emails (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
             linkedin_url TEXT,
-            scraped_info TEXT,
-            generated_subject TEXT,
-            generated_email TEXT,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            recipient_name TEXT,
+            recipient_email TEXT,
+            company_name TEXT,
+            subject_line TEXT,
+            email_body TEXT,
+            tone TEXT,
+            creativity REAL,
+            quality_score REAL,
+            generated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (linkedin_url) REFERENCES scraped_data (linkedin_url)
         )
     ''')
     
     conn.commit()
     conn.close()
 
-def save_to_database(data):
-    """Save processed data to database"""
-    conn = sqlite3.connect('leads.db')
-    cursor = conn.cursor()
+def load_email_generator():
+    """Load the email generator with caching"""
+    if st.session_state.email_generator is None:
+        with st.spinner("🤖 Loading AI model (first time may take a few minutes)..."):
+            try:
+                st.session_state.email_generator = EmailGenerator()
+                st.success("✅ AI model loaded successfully!")
+            except Exception as e:
+                st.error(f"❌ Failed to load AI model: {str(e)}")
+                st.info("💡 The model will be downloaded automatically on first run. Please ensure you have a stable internet connection.")
+                return None
+    return st.session_state.email_generator
+
+def process_csv_data(df, tone, creativity, num_variations):
+    """Process CSV data and generate emails"""
+    scraper = LinkedInScraper()
+    email_gen = load_email_generator()
     
-    for _, row in data.iterrows():
-        cursor.execute('''
-            INSERT OR REPLACE INTO scraped_data 
-            (name, email, company, linkedin_url, scraped_info, generated_subject, generated_email)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        ''', (
-            row['name'], row['email'], row['company'], row['linkedin_url'],
-            row.get('scraped_info', ''), row.get('generated_subject', ''), 
-            row.get('generated_email', '')
-        ))
+    if email_gen is None:
+        return None
     
-    conn.commit()
-    conn.close()
+    results = []
+    
+    # Progress tracking
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    for idx, row in df.iterrows():
+        progress = (idx + 1) / len(df)
+        progress_bar.progress(progress)
+        status_text.text(f"Processing {idx + 1}/{len(df)}: {row['name']} at {row['company']}")
+        
+        # Scrape company data
+        with st.spinner(f"🔍 Scraping data for {row['company']}..."):
+            company_data = scraper.scrape_company_data(row['linkedin_url'])
+        
+        # Generate emails with multiple variations
+        variations = []
+        for i in range(num_variations):
+            with st.spinner(f"✍️ Generating email variation {i+1}/{num_variations}..."):
+                email_data = email_gen.generate_email(
+                    company_data=company_data,
+                    recipient_name=row['name'],
+                    recipient_email=row['email'],
+                    tone=tone,
+                    creativity=creativity
+                )
+                if email_data:
+                    variations.append(email_data)
+        
+        # Combine all data
+        result = {
+            'name': row['name'],
+            'email': row['email'],
+            'company': row['company'],
+            'linkedin_url': row['linkedin_url'],
+            'company_description': company_data.get('description', 'N/A'),
+            'industry': company_data.get('industry', 'N/A'),
+            'website': company_data.get('website', 'N/A'),
+            'variations': variations,
+            'best_variation': max(variations, key=lambda x: x.get('quality_score', 0)) if variations else None
+        }
+        results.append(result)
+        
+        # Small delay to be respectful to servers
+        time.sleep(1)
+    
+    progress_bar.progress(1.0)
+    status_text.text("✅ Processing complete!")
+    
+    return results
 
-def load_from_database():
-    """Load data from database"""
-    conn = sqlite3.connect('leads.db')
-    df = pd.read_sql_query('SELECT * FROM scraped_data ORDER BY created_at DESC', conn)
-    conn.close()
-    return df
+def display_results(results, tone, creativity):
+    """Display results in an interactive table format"""
+    if not results:
+        st.warning("No results to display.")
+        return
+    
+    st.subheader("📊 Results Overview")
+    
+    # Summary metrics
+    col1, col2, col3, col4 = st.columns(4)
+    
+    total_leads = len(results)
+    successful_generations = sum(1 for r in results if r['best_variation'])
+    avg_quality = sum(r['best_variation']['quality_score'] for r in results if r['best_variation']) / max(successful_generations, 1)
+    
+    col1.metric("Total Leads", total_leads)
+    col2.metric("Successful Generations", successful_generations)
+    col3.metric("Average Quality Score", f"{avg_quality:.1f}/10")
+    col4.metric("Success Rate", f"{(successful_generations/total_leads)*100:.1f}%")
+    
+    # Results table
+    st.subheader("📋 Generated Emails")
+    
+    for idx, result in enumerate(results):
+        with st.expander(f"📧 {result['name']} - {result['company']}", expanded=False):
+            if not result['best_variation']:
+                st.error("❌ Failed to generate email for this contact")
+                continue
+            
+            best = result['best_variation']
+            
+            # Three columns layout
+            col1, col2, col3 = st.columns([1, 2, 1])
+            
+            with col1:
+                st.write("**Contact Info:**")
+                st.write(f"👤 **Name:** {result['name']}")
+                st.write(f"📧 **Email:** {result['email']}")
+                st.write(f"🏢 **Company:** {result['company']}")
+                st.write(f"🏭 **Industry:** {result['industry']}")
+                if result['website'] != 'N/A':
+                    st.write(f"🌐 **Website:** {result['website']}")
+                
+                # Quality indicator
+                quality = best['quality_score']
+                if quality >= 8:
+                    st.success(f"🌟 Quality: {quality:.1f}/10")
+                elif quality >= 6:
+                    st.warning(f"⚡ Quality: {quality:.1f}/10")
+                else:
+                    st.error(f"⚠️ Quality: {quality:.1f}/10")
+            
+            with col2:
+                st.write("**📧 Generated Email:**")
+                
+                # Subject line
+                st.write("**Subject:**")
+                subject_container = st.container()
+                with subject_container:
+                    st.code(best['subject_line'], language=None)
+                    if st.button(f"📋 Copy Subject", key=f"copy_subject_{idx}"):
+                        st.success("Subject copied to clipboard!")
+                
+                # Email body
+                st.write("**Email Body:**")
+                email_container = st.container()
+                with email_container:
+                    st.text_area(
+                        "Email Content",
+                        best['email_body'],
+                        height=300,
+                        key=f"email_body_{idx}",
+                        label_visibility="collapsed"
+                    )
+                    if st.button(f"📋 Copy Email", key=f"copy_email_{idx}"):
+                        st.success("Email copied to clipboard!")
+            
+            with col3:
+                st.write("**🎯 Generation Settings:**")
+                st.write(f"**Tone:** {tone}")
+                st.write(f"**Creativity:** {creativity}")
+                
+                st.write("**📊 Company Data:**")
+                if result['company_description'] != 'N/A':
+                    with st.expander("📄 Description", expanded=False):
+                        st.write(result['company_description'][:200] + "..." if len(result['company_description']) > 200 else result['company_description'])
+                
+                # Show all variations if multiple
+                if len(result['variations']) > 1:
+                    st.write(f"**🔄 Variations ({len(result['variations'])}):**")
+                    for i, var in enumerate(result['variations']):
+                        quality_color = "🌟" if var['quality_score'] >= 8 else "⚡" if var['quality_score'] >= 6 else "⚠️"
+                        if st.button(f"{quality_color} Variation {i+1} ({var['quality_score']:.1f})", key=f"var_{idx}_{i}"):
+                            # Show this variation
+                            st.info(f"**Subject:** {var['subject_line']}")
+                            st.text_area("Body", var['email_body'], height=200, key=f"var_body_{idx}_{i}")
 
-def main():
-    st.title("📧 Cold Email Outreach Assistant")
-    st.markdown("Upload your leads CSV and generate personalized cold emails using AI")
+def export_to_csv(results):
+    """Export results to CSV format"""
+    if not results:
+        return None
+    
+    export_data = []
+    for result in results:
+        if result['best_variation']:
+            best = result['best_variation']
+            export_data.append({
+                'name': result['name'],
+                'email': result['email'],
+                'company': result['company'],
+                'industry': result['industry'],
+                'website': result['website'],
+                'subject_line': best['subject_line'],
+                'email_body': best['email_body'],
+                'quality_score': best['quality_score'],
+                'linkedin_url': result['linkedin_url'],
+                'company_description': result['company_description']
+            })
     
+    return pd.DataFrame(export_data)
+
+def main():
     # Initialize database
     init_database()
     
-    # Sidebar for configuration
+    # Header
+    st.title("📧 Cold Email Outreach Assistant")
+    st.markdown("Transform your lead list into personalized, high-converting cold emails using AI")
+    
+    # Sidebar for settings
     with st.sidebar:
-        st.header("⚙️ Configuration")
-        
-        # Model configuration
-        st.subheader("AI Model Settings")
-        model_option = st.selectbox(
-            "Model Type",
-            ["Download Vicuna-7B (Recommended)", "Use Custom Model Path"]
-        )
-        
-        if model_option == "Use Custom Model Path":
-            custom_model_path = st.text_input("Custom Model Path", "")
-        else:
-            custom_model_path = None
+        st.header("🎛️ Settings")
         
         # Email generation settings
-        st.subheader("📧 Email Generation")
+        st.subheader("📝 Email Generation")
         tone = st.selectbox(
-            "Email Tone",
-            ["Professional", "Friendly", "Direct", "Authoritative"],
+            "🎭 Tone",
+            ["Professional", "Friendly", "Direct", "Casual", "Formal"],
             index=0,
-            help="Choose the tone for generated emails"
+            help="Choose the tone for your emails"
         )
         
-        temperature = st.slider(
-            "Creativity Level", 
-            min_value=0.3, 
-            max_value=1.0, 
-            value=0.7, 
+        creativity = st.slider(
+            "🎨 Creativity Level",
+            min_value=0.1,
+            max_value=1.0,
+            value=0.7,
             step=0.1,
-            help="Lower = more conservative, Higher = more creative"
+            help="Higher values = more creative but potentially less focused emails"
         )
         
-        generate_variations = st.checkbox(
-            "Generate Multiple Variations",
-            value=False,
-            help="Generate 3 different email variations per lead"
+        num_variations = st.selectbox(
+            "🔄 Email Variations",
+            [1, 2, 3],
+            index=1,
+            help="Number of email variations to generate per contact"
         )
         
-        # Scraping configuration
-        st.subheader("🔍 Scraping Settings")
-        scrape_timeout = st.slider("Scrape Timeout (seconds)", 5, 30, 10)
-        use_selenium = st.checkbox("Use Selenium (slower but more reliable)", value=False)
-    
-    # Main content area
-    tab1, tab2, tab3 = st.tabs(["📤 Upload & Process", "📊 Results", "📈 History"])
-    
-    with tab1:
-        st.header("Upload Your Leads CSV")
+        st.markdown("---")
         
-        # File upload
-        uploaded_file = st.file_uploader(
-            "Choose a CSV file",
-            type="csv",
-            help="CSV should contain columns: name, email, company, linkedin_url"
-        )
+        # Model info
+        st.subheader("🤖 AI Model")
+        st.info("**Vicuna-7B GGUF**\n\nOptimized for quality cold email generation")
         
-        if uploaded_file is not None:
-            try:
-                # Read CSV
-                df = pd.read_csv(uploaded_file)
-                
-                # Validate columns
-                required_columns = ['name', 'email', 'company', 'linkedin_url']
-                missing_columns = [col for col in required_columns if col not in df.columns]
-                
-                if missing_columns:
-                    st.error(f"Missing required columns: {', '.join(missing_columns)}")
-                    st.info("Required columns: name, email, company, linkedin_url")
-                else:
-                    st.success(f"✅ CSV loaded successfully! Found {len(df)} leads")
-                    st.dataframe(df.head())
-                    
-                    # Process data button
-                    if st.button("🚀 Start Processing", type="primary"):
-                        process_leads(df, scrape_timeout, use_selenium, custom_model_path, tone, temperature, generate_variations)
-                        
-            except Exception as e:
-                st.error(f"Error reading CSV: {str(e)}")
+        if st.button("🔄 Reload Model"):
+            st.session_state.email_generator = None
+            st.experimental_rerun()
     
-    with tab2:
-        st.header("Processing Results")
-        
-        if st.session_state.processed_data is not None:
-            df = st.session_state.processed_data
+    # File upload
+    st.subheader("📁 Upload Your Lead List")
+    uploaded_file = st.file_uploader(
+        "Choose a CSV file",
+        type=['csv'],
+        help="Upload a CSV file with columns: name, email, company, linkedin_url"
+    )
+    
+    # Sample CSV download
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("📥 Download Sample CSV"):
+            sample_data = {
+                'name': ['John Smith', 'Jane Doe', 'Mike Johnson'],
+                'email': ['[email protected]', '[email protected]', '[email protected]'],
+                'company': ['TechCorp Inc', 'StartupXYZ', 'Creative Agency'],
+                'linkedin_url': [
+                    'https://linkedin.com/company/techcorp',
+                    'https://linkedin.com/company/startupxyz',
+                    'https://linkedin.com/company/creative-agency'
+                ]
+            }
+            sample_df = pd.DataFrame(sample_data)
+            csv = sample_df.to_csv(index=False)
+            st.download_button(
+                "📄 sample_leads.csv",
+                csv,
+                "sample_leads.csv",
+                "text/csv"
+            )
+    
+    if uploaded_file is not None:
+        try:
+            # Load and validate CSV
+            df = pd.read_csv(uploaded_file)
             
-            # Display results
-            st.success(f"✅ Processed {len(df)} leads successfully!")
+            st.success(f"✅ Loaded {len(df)} leads from CSV")
             
-            # Show detailed results
-            for idx, row in df.iterrows():
-                with st.expander(f"📋 {row['name']} - {row['company']} {'🎯' if row.get('tone_used') else ''}"):
-                    col1, col2, col3 = st.columns([2, 3, 1])
-                    
-                    with col1:
-                        st.subheader("📊 Scraped Information")
-                        st.text_area("Company Info", row.get('scraped_info', 'No info scraped'), height=100, key=f"info_{idx}")
-                        
-                        # Show generation settings if available
-                        if row.get('tone_used'):
-                            st.write(f"**Tone:** {row.get('tone_used', 'N/A')}")
-                            st.write(f"**Temperature:** {row.get('temperature_used', 'N/A')}")
-                    
-                    with col2:
-                        st.subheader("📧 Generated Email")
-                        subject = row.get('generated_subject', 'No subject generated')
-                        email_body = row.get('generated_email', 'No email generated')
-                        
-                        st.text_area("Subject", subject, height=50, key=f"subject_{idx}")
-                        st.text_area("Email Body", email_body, height=250, key=f"email_{idx}")
-                    
-                    with col3:
-                        st.subheader("📈 Quality")
-                        if subject and email_body:
-                            subject_len = len(subject)
-                            # Get main body without variations
-                            main_body = email_body.split('--- VARIATIONS ---')[0].strip()
-                            body_words = len(main_body.split())
-                            
-                            # Quality indicators
-                            if 15 <= subject_len <= 65:
-                                st.success(f"✅ Subject: {subject_len} chars")
-                            else:
-                                st.warning(f"⚠️ Subject: {subject_len} chars")
-                            
-                            if 25 <= body_words <= 100:
-                                st.success(f"✅ Body: {body_words} words")
-                            else:
-                                st.warning(f"⚠️ Body: {body_words} words")
-                            
-                            # Check for placeholders
-                            if '[Your Name]' in email_body or '{' in email_body:
-                                st.error("❌ Contains placeholders")
-                            else:
-                                st.success("✅ No placeholders")
-                            
-                            # Check for personalization
-                            if row['name'] in main_body and row['company'] in main_body:
-                                st.success("��� Well personalized")
-                            else:
-                                st.warning("⚠️ Low personalization")
-                            
-                            # Check for CTA
-                            cta_words = ['call', 'conversation', 'chat', 'discuss', 'talk', 'meeting']
-                            if any(word in main_body.lower() for word in cta_words):
-                                st.success("✅ Has call-to-action")
-                            else:
-                                st.warning("⚠️ Weak call-to-action")
-                            
-                            # Overall quality score
-                            quality_score = 0
-                            if 15 <= subject_len <= 65: quality_score += 20
-                            if 25 <= body_words <= 100: quality_score += 25
-                            if '[Your Name]' not in email_body: quality_score += 25
-                            if row['name'] in main_body and row['company'] in main_body: quality_score += 20
-                            if any(word in main_body.lower() for word in cta_words): quality_score += 10
-                            
-                            if quality_score >= 80:
-                                st.success(f"🏆 Overall: {quality_score}% - Ready to send!")
-                            elif quality_score >= 60:
-                                st.warning(f"📝 Overall: {quality_score}% - Needs polish")
-                            else:
-                                st.error(f"🔧 Overall: {quality_score}% - Needs work")
-                        
-                        # Quick copy button
-                        email_text = f"Subject: {subject}\n\n{email_body}"
-                        st.text_area("Copy Email", email_text, height=100, key=f"copy_{idx}")
+            # Validate required columns
+            required_columns = ['name', 'email', 'company', 'linkedin_url']
+            missing_columns = [col for col in required_columns if col not in df.columns]
             
-            # Export functionality
-            if st.button("📥 Export to CSV"):
-                csv_data = df.to_csv(index=False)
-                st.download_button(
-                    label="⬇️ Download CSV",
-                    data=csv_data,
-                    file_name=f"cold_emails_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-                    mime="text/csv"
-                )
-        else:
-            st.info("👆 Upload and process a CSV file to see results here")
-    
-    with tab3:
-        st.header("Processing History")
-        
-        # Load and display historical data
-        try:
-            history_df = load_from_database()
-            if not history_df.empty:
-                st.dataframe(history_df)
-                
-                # Export history
-                if st.button("📥 Export History"):
-                    csv_data = history_df.to_csv(index=False)
-                    st.download_button(
-                        label="⬇️ Download History CSV",
-                        data=csv_data,
-                        file_name=f"email_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-                        mime="text/csv"
-                    )
-            else:
-                st.info("No historical data found")
-        except Exception as e:
-            st.error(f"Error loading history: {str(e)}")
-
-def process_leads(df, scrape_timeout, use_selenium, custom_model_path, tone, temperature, generate_variations):
-    """Process the uploaded leads with enhanced email generation"""
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    try:
-        # Initialize components
-        status_text.text("🔧 Initializing scraper...")
-        scraper = LinkedInScraper(timeout=scrape_timeout, use_selenium=use_selenium)
-        
-        status_text.text("🤖 Initializing AI model...")
-        if st.session_state.email_generator is None:
-            st.session_state.email_generator = EmailGenerator(custom_model_path)
-        
-        email_gen = st.session_state.email_generator
-        
-        # Process each lead
-        processed_data = []
-        total_leads = len(df)
-        
-        for idx, row in df.iterrows():
-            status_text.text(f"🔍 Processing {row['name']} ({idx + 1}/{total_leads})")
+            if missing_columns:
+                st.error(f"❌ Missing required columns: {missing_columns}")
+                st.info("Required columns: name, email, company, linkedin_url")
+                return
             
-            # Scrape information
-            scraped_info = scraper.scrape_linkedin_or_company(
-                row['linkedin_url'], 
-                row['company']
-            )
+            # Display preview
+            with st.expander("👀 Preview Data", expanded=True):
+                st.dataframe(df.head())
             
-            # Generate email with new parameters
-            status_text.text(f"✍️ Generating email for {row['name']} ({tone} tone)...")
+            # Validate data
+            issues = []
+            if df['email'].isnull().any():
+                issues.append("Some emails are missing")
+            if df['linkedin_url'].isnull().any():
+                issues.append("Some LinkedIn URLs are missing")
             
-            if generate_variations:
-                # Generate multiple variations
-                variations = email_gen.generate_multiple_variations(
-                    row['name'], 
-                    row['company'], 
-                    scraped_info,
-                    num_variations=3,
-                    tone=tone
-                )
-                
-                # Use the first variation as primary
-                subject = variations[0]['subject']
-                email_body = variations[0]['email_body']
+            if issues:
+                st.warning("⚠️ Data Issues Found:")
+                for issue in issues:
+                    st.write(f"- {issue}")
                 
-                # Store all variations in a formatted way
-                variations_text = "\n\n--- VARIATIONS ---\n"
-                for i, var in enumerate(variations, 1):
-                    variations_text += f"\nVariation {i} ({var['tone']}):\n"
-                    variations_text += f"Subject: {var['subject']}\n"
-                    variations_text += f"Body: {var['email_body']}\n"
+                if not st.checkbox("Continue anyway?"):
+                    return
+            
+            # Process button
+            if st.button("🚀 Generate Cold Emails", type="primary"):
+                if len(df) > 10:
+                    st.warning("⚠️ Processing more than 10 leads may take several minutes. Consider processing in smaller batches.")
+                    if not st.checkbox("I understand this may take a while"):
+                        return
                 
-                email_body += variations_text
+                # Process the data
+                with st.spinner("🔄 Processing leads and generating emails..."):
+                    results = process_csv_data(df, tone, creativity, num_variations)
                 
-            else:
-                # Generate single email with specified parameters
-                subject, email_body = email_gen.generate_email(
-                    row['name'], 
-                    row['company'], 
-                    scraped_info,
-                    tone=tone,
-                    temperature=temperature
-                )
-            
-            # Add to processed data
-            processed_data.append({
-                'name': row['name'],
-                'email': row['email'],
-                'company': row['company'],
-                'linkedin_url': row['linkedin_url'],
-                'scraped_info': scraped_info,
-                'generated_subject': subject,
-                'generated_email': email_body,
-                'tone_used': tone,
-                'temperature_used': temperature
-            })
-            
-            # Update progress
-            progress_bar.progress((idx + 1) / total_leads)
-        
-        # Convert to DataFrame and save
-        result_df = pd.DataFrame(processed_data)
-        st.session_state.processed_data = result_df
-        
-        # Save to database
-        save_to_database(result_df)
-        
-        status_text.text("✅ Processing completed!")
-        st.success("🎉 All leads processed successfully!")
+                if results:
+                    st.session_state.processed_data = results
+                    st.success("✅ Email generation complete!")
+                else:
+                    st.error("❌ Failed to process leads. Please try again.")
         
-        # Show quality metrics
-        avg_subject_length = result_df['generated_subject'].str.len().mean()
-        avg_body_length = result_df['generated_email'].str.split().str.len().mean()
+        except Exception as e:
+            st.error(f"❌ Error reading CSV file: {str(e)}")
+            st.info("Please ensure your CSV file has the correct format and encoding.")
+    
+    # Display results if available - This is where the error was happening
+    if st.session_state.processed_data is not None:
+        st.markdown("---")
+        display_results(st.session_state.processed_data, tone, creativity)
         
-        st.info(f"📊 Quality Metrics: Avg subject length: {avg_subject_length:.0f} chars, Avg body length: {avg_body_length:.0f} words")
+        # Export functionality
+        st.markdown("---")
+        st.subheader("📤 Export Results")
         
-    except Exception as e:
-        st.error(f"❌ Error during processing: {str(e)}")
-        status_text.text("❌ Processing failed")
+        export_df = export_to_csv(st.session_state.processed_data)
+        if export_df is not None:
+            csv = export_df.to_csv(index=False)
+            st.download_button(
+                "📥 Download Results as CSV",
+                csv,
+                f"cold_emails_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                "text/csv",
+                help="Download all generated emails in CSV format"
+            )
+            
+            st.info(f"📊 Ready to export {len(export_df)} successful email generations")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        """
+        <div style='text-align: center; color: #666;'>
+            <p>🚀 Cold Email Outreach Assistant | Built with Streamlit & Vicuna-7B</p>
+            <p>💡 Tip: Use specific, researched LinkedIn company URLs for best results</p>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
 
 if __name__ == "__main__":
     main()