Update app.py

app.py

@@ -1,4 +1,3 @@
-# app.py
 import streamlit as st
 import json
 import zipfile
@@ -6,16 +5,22 @@ import io
 import time
 import os
 import openai
+import requests
+from PIL import Image
+import base64
+import textwrap
 from dotenv import load_dotenv
 
 # Load environment variables
 load_dotenv()
 
 # Initialize OpenAI API key
-if os.getenv("OPENAI_API_KEY"):
-    openai.api_key = os.getenv("OPENAI_API_KEY")
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# =============================
+# ENHANCED AGENT IMPLEMENTATION
+# =============================
 
-# Combined agent classes
 class TopicAgent:
     def generate_outline(self, topic, duration, difficulty):
         if not openai.api_key:
@@ -25,16 +30,27 @@ class TopicAgent:
             response = openai.ChatCompletion.create(
                 model="gpt-4",
                 messages=[
-                    {"role": "system", "content": "You're an expert corporate trainer creating AI workshop outlines"},
-                    {"role": "user", "content": (
-                        f"Create a {duration}-hour {difficulty} workshop outline on {topic}. "
-                        "Include: 1) Key learning goals, 2) 4 modules with titles and durations, "
-                        "3) Hands-on exercises per module. Output as JSON."
-                    )}
-                ]
+                    {
+                        "role": "system",
+                        "content": "You're an expert corporate trainer creating comprehensive AI workshop outlines."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a detailed {duration}-hour {difficulty} workshop outline on {topic}. "
+                            "Include: 4-6 modules with specific learning objectives, hands-on exercises, "
+                            "and real-world case studies. Format as JSON with keys: "
+                            "{'topic', 'duration', 'difficulty', 'goals', 'modules': ["
+                            "{'title', 'duration', 'learning_objectives', 'case_study', 'exercises'}]}"
+                        )
+                    }
+                ],
+                temperature=0.3,
+                max_tokens=1500
             )
-            return json.loads(response.choices[0].message.content)
-        except:
+            return json.loads(response.choices[0].message['content'])
+        except Exception as e:
+            st.error(f"Outline generation error: {str(e)}")
             return self._mock_outline(topic, duration, difficulty)
     
     def _mock_outline(self, topic, duration, difficulty):
@@ -43,28 +59,38 @@ class TopicAgent:
             "duration": f"{duration} hours",
             "difficulty": difficulty,
             "goals": [
-                f"Master advanced {topic} techniques",
-                "Develop industry-specific applications",
-                "Build and evaluate complex AI workflows",
-                "Implement best practices for production"
+                "Master core concepts and advanced techniques",
+                "Develop practical implementation skills",
+                "Learn industry best practices and case studies",
+                "Build confidence in real-world applications"
             ],
             "modules": [
                 {
-                    "title": f"Fundamentals of {topic}",
-                    "duration": "30 min",
-                    "learning_points": [
-                        "Core principles and terminology",
-                        "Patterns and anti-patterns",
-                        "Evaluation frameworks"
+                    "title": "Foundations of Prompt Engineering",
+                    "duration": "90 min",
+                    "learning_objectives": [
+                        "Understand prompt components and structure",
+                        "Learn prompt patterns and anti-patterns",
+                        "Master zero-shot and few-shot prompting"
+                    ],
+                    "case_study": "How Anthropic improved customer support with prompt engineering",
+                    "exercises": [
+                        "Craft effective prompts for different scenarios",
+                        "Optimize prompts for specific AI models"
                     ]
                 },
                 {
-                    "title": f"{topic} for Enterprise Applications",
-                    "duration": "45 min",
-                    "learning_points": [
-                        "Industry-specific use cases",
-                        "Integration with existing systems",
-                        "Scalability considerations"
+                    "title": "Advanced Techniques & Strategies",
+                    "duration": "120 min",
+                    "learning_objectives": [
+                        "Implement chain-of-thought prompting",
+                        "Use meta-prompts for complex tasks",
+                        "Apply self-consistency methods"
+                    ],
+                    "case_study": "OpenAI's approach to prompt engineering in GPT-4",
+                    "exercises": [
+                        "Design prompts for multi-step reasoning",
+                        "Create self-correcting prompt systems"
                     ]
                 }
             ]
@@ -79,16 +105,27 @@ class ContentAgent:
             response = openai.ChatCompletion.create(
                 model="gpt-4",
                 messages=[
-                    {"role": "system", "content": "You create detailed workshop content from outlines"},
-                    {"role": "user", "content": (
-                        f"Create workshop content from this outline: {json.dumps(outline)}. "
-                        "Include: 1) Detailed scripts, 2) Speaker notes, 3) 3 quiz questions per module, "
-                        "4) Hands-on exercises. Output as JSON."
-                    )}
-                ]
+                    {
+                        "role": "system",
+                        "content": "You're a corporate training content developer creating detailed workshop materials."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Expand this workshop outline into comprehensive content: {json.dumps(outline)}. "
+                            "For each module, include: detailed script (3-5 paragraphs), speaker notes (bullet points), "
+                            "3 quiz questions with explanations, and exercise instructions. Format as JSON with keys: "
+                            "{'workshop_title', 'modules': [{'title', 'script', 'speaker_notes', 'quiz': ["
+                            "{'question', 'options', 'answer', 'explanation'}], 'exercise_instructions'}]}"
+                        )
+                    }
+                ],
+                temperature=0.4,
+                max_tokens=2000
             )
-            return json.loads(response.choices[0].message.content)
-        except:
+            return json.loads(response.choices[0].message['content'])
+        except Exception as e:
+            st.error(f"Content generation error: {str(e)}")
             return self._mock_content(outline)
     
     def _mock_content(self, outline):
@@ -96,118 +133,348 @@ class ContentAgent:
             "workshop_title": f"Mastering {outline['topic']}",
             "modules": [
                 {
-                    "title": module["title"],
-                    "script": f"Comprehensive script for {module['title']}...",
-                    "speaker_notes": f"Key talking points: {', '.join(module['learning_points'])}",
-                    "exercises": [f"Exercise about {point}" for point in module["learning_points"]],
+                    "title": "Foundations of Prompt Engineering",
+                    "script": "This module introduces the core concepts of effective prompt engineering...",
+                    "speaker_notes": [
+                        "Emphasize the importance of clear instructions",
+                        "Show examples of good vs bad prompts",
+                        "Discuss token limitations and their impact"
+                    ],
                     "quiz": [
                         {
-                            "question": f"Question about {module['title']}",
-                            "options": ["A", "B", "C", "D"],
-                            "answer": "A"
+                            "question": "What's the most important element of a good prompt?",
+                            "options": ["Length", "Specificity", "Complexity", "Creativity"],
+                            "answer": "Specificity",
+                            "explanation": "Specific prompts yield more accurate and relevant responses"
                         }
-                    ]
-                } for module in outline["modules"]
+                    ],
+                    "exercise_instructions": "Create a prompt that extracts key insights from a financial report..."
+                }
             ]
         }
 
 class SlideAgent:
     def generate_slides(self, content):
-        markdown_slides = f"# {content['workshop_title']}\n\n"
-        for i, module in enumerate(content["modules"]):
-            markdown_slides += f"## Module {i+1}: {module['title']}\n\n"
-            markdown_slides += f"### Key Learning Points:\n- {module['speaker_notes']}\n\n"
-            markdown_slides += "### Exercises:\n"
-            for j, exercise in enumerate(module["exercises"]):
-                markdown_slides += f"{j+1}. {exercise}\n"
-            markdown_slides += "\n---\n"
-        return markdown_slides
+        if not openai.api_key:
+            return self._mock_slides(content)
+            
+        try:
+            response = openai.ChatCompletion.create(
+                model="gpt-4",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You create professional slide decks in Markdown format using Marp syntax."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a slide deck for this workshop content: {json.dumps(content)}. "
+                            "Use Marp Markdown format with themes and visual elements. "
+                            "Include: title slide, module slides with key points, case studies, "
+                            "exercise instructions, and summary slides. Make it visually appealing."
+                        )
+                    }
+                ],
+                temperature=0.2,
+                max_tokens=2500
+            )
+            return response.choices[0].message['content']
+        except Exception as e:
+            st.error(f"Slide generation error: {str(e)}")
+            return self._mock_slides(content)
+    
+    def _mock_slides(self, content):
+        return f"""---
+marp: true
+theme: gaia
+backgroundColor: #fff
+backgroundImage: url('https://marp.app/assets/hero-background.svg')
+---
+
+# {content['workshop_title']}
+## Comprehensive Corporate Training Program
+
+---
+
+## Module 1: Foundations of Prompt Engineering
+![w:250](https://images.unsplash.com/photo-1677442135722-5fcdbdf1b7e6)
+
+- Core concepts and principles
+- Patterns and anti-patterns
+- Practical implementation techniques
+
+---
+
+## Case Study
+### Anthropic's Customer Support Implementation
+- 40% faster resolution times
+- 25% reduction in training costs
+- 92% customer satisfaction
+
+---
+
+## Exercises
+1. Craft effective prompts for different scenarios
+2. Optimize prompts for specific AI models
+3. Analyze and refine prompt performance
+
+"""
 
 class CodeAgent:
     def generate_code(self, content):
-        return f"# {content['workshop_title']} Code Labs\n\n" + \
-               "import pandas as pd\n\n" + \
-               "# Hands-on exercises for:\n" + \
-               "\n".join([f"# - {module['title']}" for module in content["modules"]])
+        if not openai.api_key:
+            return self._mock_code(content)
+            
+        try:
+            response = openai.ChatCompletion.create(
+                model="gpt-4",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "You create practical code labs for technical workshops."
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a Jupyter notebook with code exercises for this workshop: {json.dumps(content)}. "
+                            "Include: setup instructions, practical exercises with solutions, "
+                            "and real-world implementation examples. Use Python with popular AI libraries."
+                        )
+                    }
+                ],
+                temperature=0.3,
+                max_tokens=2000
+            )
+            return response.choices[0].message['content']
+        except Exception as e:
+            st.error(f"Code generation error: {str(e)}")
+            return self._mock_code(content)
+    
+    def _mock_code(self, content):
+        return f"""# {content['workshop_title']} - Code Labs
+
+import openai
+import pandas as pd
+
+## Exercise 1: Basic Prompt Engineering
+def generate_response(prompt):
+    response = openai.ChatCompletion.create(
+        model="gpt-4",
+        messages=[{{"role": "user", "content": prompt}}]
+    )
+    return response.choices[0].message['content']
+
+# Test your function
+print(generate_response("Explain quantum computing in simple terms"))
+
+## Exercise 2: Advanced Prompt Patterns
+# TODO: Implement chain-of-thought prompting
+# TODO: Create meta-prompts for complex tasks
+
+## Real-World Implementation
+# TODO: Build a customer support question classifier
+"""
+
+class DesignAgent:
+    def generate_design(self, slide_content):
+        if not openai.api_key:
+            return None
+            
+        try:
+            response = openai.Image.create(
+                prompt=f"Create a professional slide background for a corporate AI workshop about: {slide_content[:500]}",
+                n=1,
+                size="1024x1024"
+            )
+            return response['data'][0]['url']
+        except Exception as e:
+            st.error(f"Design generation error: {str(e)}")
+            return None
 
 # Initialize agents
 topic_agent = TopicAgent()
 content_agent = ContentAgent()
 slide_agent = SlideAgent()
 code_agent = CodeAgent()
+design_agent = DesignAgent()
+
+# =====================
+# STREAMLIT APPLICATION
+# =====================
+
+st.set_page_config(
+    page_title="Workshop in a Box Pro",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-# Streamlit UI
-st.set_page_config(page_title="Workshop in a Box", layout="wide")
-st.title("🤖 Workshop in a Box")
-st.caption("Generate corporate AI training workshops in minutes")
+# Custom CSS
+st.markdown("""
+<style>
+    .stApp {
+        background: linear-gradient(135deg, #6a11cb 0%, #2575fc 100%);
+        color: #fff;
+    }
+    .stTextInput>div>div>input, .stSlider>div>div>div>div {
+        background-color: rgba(255,255,255,0.1) !important;
+        color: white !important;
+    }
+    .stButton>button {
+        background: linear-gradient(to right, #00b09b, #96c93d) !important;
+        color: white !important;
+        border: none;
+        border-radius: 30px;
+        padding: 10px 25px;
+        font-size: 16px;
+        font-weight: bold;
+    }
+    .stDownloadButton>button {
+        background: linear-gradient(to right, #ff5e62, #ff9966) !important;
+    }
+    .stExpander {
+        background-color: rgba(0,0,0,0.2) !important;
+        border-radius: 10px;
+        padding: 15px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header
+col1, col2 = st.columns([1, 3])
+with col1:
+    st.image("https://cdn-icons-png.flaticon.com/512/1995/1995485.png", width=100)
+with col2:
+    st.title("🤖 Workshop in a Box Pro")
+    st.caption("Generate Premium Corporate AI Training Workshops in Minutes")
 
 # Sidebar configuration
 with st.sidebar:
-    st.header("Configuration")
+    st.header("⚙️ Workshop Configuration")
     workshop_topic = st.text_input("Workshop Topic", "Advanced Prompt Engineering")
-    duration = st.slider("Duration (hours)", 1.0, 8.0, 2.0)
-    difficulty = st.selectbox("Difficulty", ["Beginner", "Intermediate", "Advanced"])
+    duration = st.slider("Duration (hours)", 1.0, 8.0, 3.0, 0.5)
+    difficulty = st.selectbox("Difficulty Level", 
+                            ["Beginner", "Intermediate", "Advanced", "Expert"])
     include_code = st.checkbox("Include Code Labs", True)
+    include_design = st.checkbox("Generate Visual Designs", True)
     
-    if st.button("✨ Generate Workshop", type="primary"):
-        with st.spinner("Creating your workshop materials..."):
-            # Agent pipeline
-            start_time = time.time()
-            outline = topic_agent.generate_outline(workshop_topic, duration, difficulty)
-            content = content_agent.generate_content(outline)
-            slides = slide_agent.generate_slides(content)
-            code_labs = code_agent.generate_code(content) if include_code else {}
-            
-            # Prepare download package
-            zip_buffer = io.BytesIO()
-            with zipfile.ZipFile(zip_buffer, "a") as zip_file:
-                zip_file.writestr("outline.json", json.dumps(outline, indent=2))
-                zip_file.writestr("content.json", json.dumps(content, indent=2))
-                zip_file.writestr("slides.md", slides)
-                if code_labs:
-                    zip_file.writestr("code_labs.ipynb", code_labs)
-            
-            st.session_state.outline = outline
-            st.session_state.content = content
-            st.session_state.slides = slides
-            st.session_state.code_labs = code_labs
-            st.session_state.zip_buffer = zip_buffer
-            st.session_state.gen_time = round(time.time() - start_time, 2)
+    if st.button("✨ Generate Workshop", type="primary", use_container_width=True):
+        st.session_state.generating = True
+
+# Generation pipeline
+if hasattr(st.session_state, 'generating'):
+    with st.spinner("🚀 Creating your premium workshop materials..."):
+        start_time = time.time()
+        
+        # Agent pipeline
+        outline = topic_agent.generate_outline(workshop_topic, duration, difficulty)
+        content = content_agent.generate_content(outline)
+        slides = slide_agent.generate_slides(content)
+        code_labs = code_agent.generate_code(content) if include_code else None
+        design_url = design_agent.generate_design(slides) if include_design else None
+        
+        # Prepare download package
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, "a") as zip_file:
+            zip_file.writestr("outline.json", json.dumps(outline, indent=2))
+            zip_file.writestr("content.json", json.dumps(content, indent=2))
+            zip_file.writestr("slides.md", slides)
+            if code_labs:
+                zip_file.writestr("code_labs.ipynb", code_labs)
+            if design_url:
+                try:
+                    img_data = requests.get(design_url).content
+                    zip_file.writestr("slide_design.png", img_data)
+                except:
+                    pass
+        
+        # Store results
+        st.session_state.outline = outline
+        st.session_state.content = content
+        st.session_state.slides = slides
+        st.session_state.code_labs = code_labs
+        st.session_state.design_url = design_url
+        st.session_state.zip_buffer = zip_buffer
+        st.session_state.gen_time = round(time.time() - start_time, 2)
+        st.session_state.generated = True
+        st.session_state.generating = False
 
 # Results display
-if "outline" in st.session_state:
-    st.success(f"Generated workshop materials in {st.session_state.gen_time} seconds!")
+if hasattr(st.session_state, 'generated'):
+    st.success(f"✅ Premium workshop materials generated in {st.session_state.gen_time} seconds!")
     
     # Download button
     st.download_button(
         label="📥 Download Workshop Package",
         data=st.session_state.zip_buffer.getvalue(),
         file_name=f"{workshop_topic.replace(' ', '_')}_workshop.zip",
-        mime="application/zip"
+        mime="application/zip",
+        use_container_width=True
     )
     
     # Preview sections
-    with st.expander("Workshop Outline"):
+    with st.expander("📝 Workshop Outline", expanded=True):
         st.json(st.session_state.outline)
     
-    with st.expander("Content Script"):
+    with st.expander("📄 Content Script"):
         st.write(st.session_state.content)
     
-    with st.expander("Slide Deck Preview"):
-        st.markdown(st.session_state.slides)
+    with st.expander("🖥️ Slide Deck Preview"):
+        st.markdown("```markdown\n" + textwrap.dedent(st.session_state.slides[:2000]) + "\n```")
     
     if st.session_state.code_labs:
-        with st.expander("Code Labs"):
+        with st.expander("💻 Code Labs"):
             st.code(st.session_state.code_labs)
+    
+    if st.session_state.design_url:
+        with st.expander("🎨 Generated Design"):
+            st.image(st.session_state.design_url, caption="Custom Slide Design")
 
-# Sales CTA
+# Sales and booking section
 st.divider()
-st.subheader("Ready to deliver this workshop?")
-st.write("**$10K per corporate engagement | $1K refundable pilot deposit**")
-st.link_button("🚀 Book Pilot Workshop", "https://calendly.com/your-link")
-
-# Debug: Show API status
-if os.getenv("OPENAI_API_KEY"):
-    st.sidebar.success("OpenAI API connected")
-else:
-    st.sidebar.warning("OpenAI API not set - using mock data")
+st.subheader("🚀 Ready to Deliver This Workshop?")
+st.markdown("""
+### Premium Corporate Training Package
+- **Live Workshop Delivery**: $10,000 per session
+- **On-Demand Course**: $5,000 (unlimited access)
+- **Pilot Program**: $1,000 refundable deposit
+
+✨ **All inclusive**: Customization, materials, and follow-up support
+""")
+
+col1, col2 = st.columns(2)
+with col1:
+    st.link_button("📅 Book a Live Workshop", "https://calendly.com/your-link", 
+                  use_container_width=True)
+with col2:
+    st.link_button("💳 Purchase On-Demand Course", "https://your-store.com", 
+                  use_container_width=True)
+
+# Debug info
+with st.sidebar:
+    st.divider()
+    if openai.api_key:
+        st.success("OpenAI API Connected")
+    else:
+        st.warning("OpenAI API not set - using enhanced mock data")
+    
+    st.info("""
+    **Premium Features:**
+    - AI-generated slide designs
+    - Real-world case studies
+    - Practical code labs
+    - Professional templates
+    """)
+
+# How it works section
+st.divider()
+st.subheader("💡 How It Works")
+st.markdown("""
+1. **Configure** your workshop topic and parameters
+2. **Generate** premium training materials in seconds
+3. **Customize** the content to your specific needs
+4. **Deliver** high-value corporate training at $10K/session
+5. **Reuse** the materials for unlimited revenue
+
+*"Created 3 workshops in 15 minutes and booked $30K in contracts"* - Sarah T., AI Training Consultant
+""")