Upload 4 files

README (1).md

@@ -0,0 +1,114 @@
+---
+title: AI Marketing Content Generator
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.33.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🎨 AI Marketing Content Generator
+
+Generate professional marketing images with AI using FLUX.1-schnell. Perfect for content creators, marketers, and social media managers!
+
+## ✨ Features
+
+### 🖼️ Single Image Generation
+- Create individual marketing assets
+- Apply professional style presets
+- Optimized prompts for marketing content
+
+### 🔄 A/B Testing Batch
+- Generate multiple variations of the same concept
+- Compare different approaches
+- Perfect for testing engagement
+
+### 📱 Social Media Pack  
+- Generate platform-optimized images
+- Support for Instagram, Twitter, LinkedIn, Facebook, YouTube
+- Correct aspect ratios for each platform
+
+### 📝 Prompt Templates
+- Pre-built templates for common use cases
+- Product photography, social announcements, blog headers
+- Easy variable substitution
+
+## 🚀 How to Use
+
+1. **Choose Your Task**: Select the appropriate tab
+2. **Enter Your Prompt**: Be specific about what you want
+3. **Adjust Settings**: Style and quality options
+4. **Generate**: Click the button and wait for results
+
+## 💡 Pro Tips
+
+- **Be Specific**: "Red sports car on mountain road at sunset" > "car"
+- **Use Style Presets**: Apply consistent branding with style options
+- **FLUX.1-schnell is Fast**: Works best with 1-4 inference steps
+- **Test Variations**: Use A/B testing to find what works best
+
+## 🎯 Example Prompts
+
+### Product Photography
+```
+Professional product photography of wireless headphones, white background, studio lighting, commercial style
+```
+
+### Social Media Post
+```
+Vibrant Instagram post announcing summer sale, bold colors, modern design, eye-catching
+```
+
+### Blog Header
+```
+Minimalist blog header about productivity tips, clean design, professional, engaging
+```
+
+## 🛠️ Technical Details
+
+- **Model**: FLUX.1-schnell (Schwarzer Labs)
+- **Backend**: Hugging Face Diffusers + Inference API
+- **Frontend**: Gradio
+- **Inference Steps**: 1-4 (optimized for speed)
+
+## 📊 Supported Platforms & Sizes
+
+| Platform | Resolution |
+|----------|------------|
+| Instagram Post | 1024×1024 |
+| Instagram Story | 1024×1820 |
+| Twitter Post | 1200×675 |
+| LinkedIn Post | 1200×1200 |
+| Facebook Cover | 1200×630 |
+| YouTube Thumbnail | 1280×720 |
+
+## ⚡ Performance
+
+- **Generation Time**: 10-30 seconds per image
+- **Model**: Optimized for speed and quality
+- **Hardware**: Runs on Hugging Face Spaces infrastructure
+
+## 🔧 Setup for Your Own Space
+
+1. **Fork this Space** or create a new one
+2. **Set Environment Variables**:
+   - `HF_TOKEN`: Your Hugging Face token (for API access)
+3. **Choose Hardware**: CPU (free) or GPU (faster)
+4. **Deploy**: Push your changes
+
+## 📝 License
+
+MIT License - Feel free to use and modify for your projects!
+
+## 🤝 Contributing
+
+Issues and pull requests welcome! Help make this tool even better for the marketing community.
+
+---
+
+**Made with ❤️ for content creators and marketers**
+
+*Powered by FLUX.1-schnell, Hugging Face, and Gradio*

app.py

@@ -0,0 +1,932 @@
+import gradio as gr
+import base64
+import asyncio
+import json
+import os
+from mcp import ClientSession, StdioServerParameters, types
+from mcp.client.stdio import stdio_client
+from typing import List
+import nest_asyncio
+import threading
+import queue
+import time
+from PIL import Image
+from io import BytesIO
+os.makedirs("ContentCreator/created_image", exist_ok=True)
+
+nest_asyncio.apply()
+
+
+class MCP_Modal_Marketing_Tool:
+    def __init__(self):
+        self.session: ClientSession = None
+        self.available_tools: List[dict] = []
+        self.is_connected = False
+        self.request_queue = queue.Queue()
+        self.result_queue = queue.Queue()
+
+    async def call_mcp_tool(self, tool_name: str, arguments: dict):
+        """Generic method to call any MCP tool"""
+        try:
+            result = await self.session.call_tool(tool_name, arguments=arguments)
+            if hasattr(result, 'content') and result.content:
+                return result.content[0].text
+            return None
+        except Exception as e:
+            print(f"Error calling tool {tool_name}: {str(e)}")
+            raise e
+
+    async def process_queue(self):
+        """Process requests from the queue"""
+        while True:
+            try:
+                if not self.request_queue.empty():
+                    item = self.request_queue.get()
+                    if item == "STOP":
+                        break
+
+                    tool_name, arguments, request_id = item
+                    try:
+                        result = await self.call_mcp_tool(tool_name, arguments)
+                        self.result_queue.put(("success", result, request_id))
+                    except Exception as e:
+                        self.result_queue.put(("error", str(e), request_id))
+                else:
+                    await asyncio.sleep(0.1)
+            except Exception as e:
+                print(f"Error in process_queue: {str(e)}")
+
+    async def connect_to_server_and_run(self):
+        """Connect to MCP server and start processing"""
+        server_params = StdioServerParameters(
+            command="python",
+            args=["mcp_server.py"],
+            env=None,
+        )
+
+        async with stdio_client(server_params) as (read, write):
+            async with ClientSession(read, write) as session:
+                self.session = session
+                await session.initialize()
+
+                response = await session.list_tools()
+                tools = response.tools
+                print("Connected to MCP server with tools:",
+                      [tool.name for tool in tools])
+
+                self.available_tools = [{
+                    "name": tool.name,
+                    "description": tool.description,
+                    "input_schema": tool.inputSchema
+                } for tool in tools]
+
+                self.is_connected = True
+                print("Marketing Tool MCP Server connected!")
+
+                # Check Modal health
+                health_result = await self.call_mcp_tool("health_check", {})
+                print(f"Modal API Status: {health_result}")
+
+                await self.process_queue()
+
+
+# Global instance
+marketing_tool = MCP_Modal_Marketing_Tool()
+
+
+def wait_for_result(request_id, timeout=300):
+    """Wait for a result with a specific request ID"""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        if not marketing_tool.result_queue.empty():
+            status, result, result_id = marketing_tool.result_queue.get()
+            if result_id == request_id:
+                return status, result
+            else:
+                # Put it back if it's not our result
+                marketing_tool.result_queue.put((status, result, result_id))
+        time.sleep(0.1)
+    return "error", "Timeout"
+
+
+def decode_and_save_image(image_b64, filename):
+    """Decode base64 and save image"""
+    import base64
+    from PIL import Image
+    from io import BytesIO
+
+    # Ensure the path is inside created_image/
+    full_path = os.path.join("ContentCreator/created_image", filename)
+    image_b64 = image_b64.strip()
+    missing_padding = len(image_b64) % 4
+    if missing_padding:
+        image_b64 += '=' * (4 - missing_padding)
+
+    image_data = base64.b64decode(image_b64)
+    image = Image.open(BytesIO(image_data))
+    image.save(full_path)
+    return full_path
+
+
+def single_image_generation(prompt, num_steps, style):
+    """Generate a single image with optional style"""
+    if not marketing_tool.is_connected:
+        return None, "⚠️ MCP Server not connected. Please wait a few seconds and try again."
+
+    try:
+        request_id = f"single_{time.time()}"
+
+        # Apply style if selected
+        if style != "none":
+            style_request_id = f"style_{time.time()}"
+            marketing_tool.request_queue.put((
+                "add_style_modifier",
+                {"prompt": prompt, "style": style},
+                style_request_id
+            ))
+
+            status, result = wait_for_result(style_request_id, timeout=50)
+            if status == "success":
+                style_data = json.loads(result)
+                prompt = style_data["enhanced_prompt"]
+
+        # Generate image
+        marketing_tool.request_queue.put((
+            "generate_and_save_image",
+            {"prompt": prompt, "num_inference_steps": num_steps},
+            request_id
+        ))
+
+        status, result = wait_for_result(request_id)
+
+        if status == "success":
+            filename = decode_and_save_image(
+                result, f"generated_{int(time.time())}.png")
+            return filename, f"✅ Image generated successfully!\n📝 Final prompt: {prompt}"
+        else:
+            return None, f"❌ Error: {result}"
+
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+
+# Update the batch generation function in app.py
+def enhanced_batch_generation(prompt, variation_type, count, num_steps):
+    """Generate strategic variations for A/B testing"""
+    if not marketing_tool.is_connected:
+        return None, "⚠️ MCP Server not connected. Please wait a few seconds and try again."
+        
+    try:
+        request_id = f"smart_batch_{time.time()}"
+        marketing_tool.request_queue.put((
+            "batch_generate_smart_variations",
+            {
+                "prompt": prompt, 
+                "count": count, 
+                "variation_type": variation_type,
+                "num_inference_steps": num_steps
+            },
+            request_id
+        ))
+        
+        status, result = wait_for_result(request_id, timeout=300)  # Longer timeout for batch
+        
+        if status == "success":
+            batch_data = json.loads(result)
+            images = []
+            variation_details = []
+            
+            for i, img_data in enumerate(batch_data["images"]):
+                filename = decode_and_save_image(
+                    img_data["image_base64"], 
+                    f"variation_{i+1}_{int(time.time())}.png"
+                )
+                images.append(filename)
+                
+                variation_details.append(
+                    f"**Variation {i+1}:** {img_data['variation_description']}\n"
+                    f"*Testing Purpose:* {img_data['testing_purpose']}\n"
+                )
+            
+            strategy_explanation = batch_data.get("testing_strategy", "")
+            
+            status_message = (
+                f"✅ Generated {len(images)} strategic variations!\n\n"
+                f"**Testing Strategy:** {strategy_explanation}\n\n"
+                f"**Variations Created:**\n" + 
+                "\n".join(variation_details) +
+                f"\n💡 **Next Steps:** Post each variation and track engagement metrics to see which performs best!"
+            )
+            
+            return images, status_message
+        else:
+            return None, f"❌ Error: {result}"
+            
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+# Update the strategy info based on selection
+def update_strategy_info(variation_type):
+    strategy_descriptions = {
+        "mixed": {
+            "title": "Mixed Strategy Testing",
+            "description": "Tests multiple variables (colors, layout, mood) to find overall best approach",
+            "use_case": "Best for comprehensive optimization when you're not sure what to test first"
+        },
+        "color_schemes": {
+            "title": "Color Psychology Testing", 
+            "description": "Tests how different color schemes affect emotional response and engagement",
+            "use_case": "Great for brand content, product launches, and emotional marketing"
+        },
+        "composition_styles": {
+            "title": "Layout & Composition Testing",
+            "description": "Tests different visual arrangements and focal points",
+            "use_case": "Perfect for optimizing visual hierarchy and user attention flow"
+        },
+        "emotional_tones": {
+            "title": "Emotional Tone Testing",
+            "description": "Tests different moods and feelings to see what resonates with your audience", 
+            "use_case": "Ideal for brand personality and audience connection optimization"
+        },
+        "social_media": {
+            "title": "Platform Optimization Testing",
+            "description": "Tests platform-specific elements and styles",
+            "use_case": "Essential for multi-platform content strategies"
+        },
+        "engagement_hooks": {
+            "title": "Attention-Grabbing Testing",
+            "description": "Tests different ways to capture and hold viewer attention",
+            "use_case": "Critical for improving reach and stopping scroll behavior"
+        },
+        "brand_positioning": {
+            "title": "Brand Positioning Testing", 
+            "description": "Tests how different brand personalities affect audience perception",
+            "use_case": "Important for brand development and target audience alignment"
+        }
+    }
+    
+    info = strategy_descriptions.get(variation_type, strategy_descriptions["mixed"])
+    return f"""
+    **💡 Current Strategy:** {info['title']}
+    
+    **What this tests:** {info['description']}
+    
+    **Best for:** {info['use_case']}
+    """
+
+def social_media_generation(prompt, platforms, num_steps):
+    """Generate images for multiple social media platforms with correct resolutions"""
+    if not marketing_tool.is_connected:
+        return None, "MCP Server not connected"
+        
+    try:
+        request_id = f"social_{time.time()}"
+        marketing_tool.request_queue.put((
+            "generate_social_media_set",
+            {"prompt": prompt, "platforms": platforms, "num_inference_steps": num_steps},
+            request_id
+        ))
+        
+        status, result = wait_for_result(request_id)
+        
+        if status == "success":
+            social_data = json.loads(result)
+            results = []
+            
+            for platform_data in social_data["results"]:
+                filename = decode_and_save_image(
+                    platform_data["image_base64"],
+                    f"{platform_data['platform']}_{platform_data['resolution']}_{int(time.time())}.png"
+                )
+                results.append((platform_data["platform"], filename, platform_data["resolution"]))
+                
+            # Create a status message with resolutions
+            if results:
+                status_msg = "Generated images:\n" + "\n".join([
+                    f"• {r[0]}: {r[2]}" for r in results
+                ])
+                return [r[1] for r in results], status_msg
+            else:
+                return None, "No images generated"
+        else:
+            return None, f"Error: {result}"
+            
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+
+
+def start_mcp_server():
+    """Start MCP server in background"""
+    def run_server():
+        asyncio.run(marketing_tool.connect_to_server_and_run())
+
+    thread = threading.Thread(target=run_server, daemon=True)
+    thread.start()
+    return thread
+
+
+# Platform size presets for reference
+SIZE_PRESETS = {
+    "instagram_post": (1080, 1080),
+    "instagram_story": (1080, 1920),
+    "twitter_post": (1200, 675),
+    "linkedin_post": (1200, 1200),
+    "facebook_cover": (1200, 630),
+    "youtube_thumbnail": (1280, 720)
+}
+
+# Create Gradio interface with tabs
+with gr.Blocks(title="AI Marketing Content Generator") as demo:
+    gr.Markdown("""
+    # 🎨 AI Marketing Content Generator
+    ### Powered by Flux AI on Modal GPU via MCP
+    
+    Generate professional marketing images with AI - optimized for content creators and marketers!
+    
+    ⏰ **Please wait 5-10 seconds after launching for the MCP server to connect**
+    """)
+
+    # Connection status
+    connection_status = gr.Markdown("🔄 Connecting to MCP server...")
+
+    with gr.Tabs():
+        # Instructions Tab (First)
+        # Instructions Tab (First)
+        with gr.TabItem("📖 Quick Start"):
+            gr.Markdown("""
+            ## 🚀 Get Started in 3 Steps
+            
+            1. **Wait for Connection** ✅ (Status shown above)
+            2. **Pick a Tab** → Choose what you need to create
+            3. **Generate** → Enter details and click generate
+            
+            ### 🎯 What Each Tab Does:
+            - **🖼️ Single Image**: Create one professional marketing image
+            - **🔄 A/B Testing**: Generate variations to test what works best  
+            - **📱 Social Media**: Create multiple platform-sized images at once
+            - **🤖 AI Assistant**: Let AI write the perfect prompt for you
+            """)
+            
+            with gr.Accordion("📚 Detailed Guide & Tips", open=False):
+                gr.Markdown("""
+            ## Welcome to AI Marketing Content Generator! 
+            
+            This tool helps you create professional marketing images using AI. Here's how to use each feature:
+            
+            ### 🚀 Quick Start Guide
+            
+            1. **Wait for Connection**: The status above should show "✅ Connected" before you start
+            2. **Choose Your Task**: Select a tab based on what you need
+            3. **Enter Details**: Fill in the prompts and settings
+            4. **Generate**: Click the generate button and wait for results
+            
+            ### 📑 Feature Overview
+            
+            #### 1️⃣ Single Image Tab
+            - **Best for**: Individual marketing assets, blog headers, social posts
+            - **How to use**:
+                1. Enter a descriptive prompt
+                2. Choose a style preset (optional)
+                3. Adjust quality with steps (higher = better but slower)
+                4. Click Generate
+            
+            #### 2️⃣ A/B Testing Batch Tab  
+            - **Best for**: Creating variations to test engagement
+            - **How to use**:
+                1. Enter your base prompt
+                2. Select how many variations (2-5)
+                3. Generate and compare results
+            
+            #### 3️⃣ Social Media Pack Tab
+            - **Best for**: Multi-platform campaigns
+            - **How to use**:
+                1. Enter your content prompt
+                2. Check the platforms you need
+                3. Generate all sizes at once
+            
+            #### 4️⃣ Prompt Templates Tab
+            - **Best for**: Quick professional prompts
+            - **How to use**:
+                1. Select a template type
+                2. Fill in the required variables
+                3. Apply template
+                4. Use the generated prompt
+            
+            ### 💡 Pro Tips
+            
+            - **Be Specific**: "Product photo of red shoes on white background" > "shoes"
+            - **Use Styles**: Apply style presets for consistent branding
+            - **Higher Steps**: Use 70-100 steps for final production images
+            - **Test First**: Use lower steps (30-40) for quick tests
+            - **Save Prompts**: Keep successful prompts for future use
+            
+            ### 🎯 Common Use Cases
+            
+            1. **E-commerce Product Photos**
+               ```
+               Prompt: "Professional product photography of [product], white background, studio lighting"
+               Style: professional
+               Steps: 70
+               ```
+            
+            2. **Social Media Announcements**
+               ```
+               Prompt: "Eye-catching announcement graphic for [event/sale], bold colors"
+               Style: playful
+               Steps: 50
+               ```
+            
+            3. **Blog Headers**
+               ```
+               Prompt: "Minimalist header image about [topic], modern design"
+               Style: minimalist
+               Steps: 50
+               ```
+            
+            ### ⚠️ Troubleshooting
+            
+            - **"Not Connected" Error**: Wait 10 seconds and refresh the page
+            - **Timeout Errors**: The GPU might be cold starting, try again
+            - **Poor Quality**: Increase steps to 70+ for better results
+            - **Wrong Style**: Make sure to select style before generating
+            """)
+
+        # Single Image Generation Tab
+        with gr.TabItem("🖼️ Single Image"):
+            with gr.Row():
+                with gr.Column():
+                    single_prompt = gr.Textbox(
+                        label="Prompt",
+                        placeholder="Describe your image in detail...\nExample: Professional headshot of business person in modern office",
+                        lines=3
+                    )
+                    with gr.Row():
+                        single_style = gr.Dropdown(
+                            choices=["none", "professional", "playful",
+                                     "minimalist", "luxury", "tech"],
+                            value="none",
+                            label="Style Preset",
+                            info="Apply a consistent style to your image"
+                        )
+                        single_steps = gr.Slider(
+                            10, 100, 50,
+                            step=10,
+                            label="Quality (Inference Steps)",
+                            info="Higher = better quality but slower"
+                        )
+                    single_btn = gr.Button(
+                        "🎨 Generate Image", variant="primary", size="lg")
+
+                    # Quick examples
+                    with gr.Accordion("💭 Example Ideas",open=False):
+                        gr.Examples(
+                            examples=[
+                                ["""This poster is dominated by blue-purple neon lights, with the background of a hyper city at night, with towering skyscrapers surrounded by colorful LED light strips. In the center of the picture is a young steampunk modern robot with virtual information interfaces and digital codes floating around him. The future fonted title "CYNAPTICS" is in neon blue, glowing, as if outlined by laser, exuding a sense of technology and a cold and mysterious atmosphere. The small words "FUTURE IS NOW" seem to be calling the audience to the future, full of science fiction and trendy charm""", "professional", 50],
+                                ["poster of,a white girl,A young korean woman pose with a white Vespa scooter on a sunny day,dressed in a stylish red and white jacket .inside a jacket is strapless,with a casual denim skirt. She wears a helmet with vintage-style goggles,and converse sneakers,adding a retro touch to her outfit. The bright sunlight highlights her relaxed and cheerful expression,and the Vespa’s white color pops against the clear blue sky. The background features a vibrant,sunlit scene with a few trees or distant buildings,creating a fresh and joyful atmosphere. Art style: realistic,high detail,vibrant colors,warm and cheerful.,f1.4 50mm,commercial photo style,with text around is 'Chasing the sun on my Vespa nothing but the open road ahead'", "playful", 40],
+                                ["""Badminton is not just about winning, it’s about daring to challenge the limits of speed and precision. It’s a game where every strike is a test of reflexes, every point a moment of courage. To play badminton is to engage in a battle of endurance, strategy, and passion.""", "minimalist", 50],
+                                ],
+                            inputs=[single_prompt, single_style, single_steps],
+                            label="Quick Examples"
+                            )
+
+                with gr.Column():
+                    single_output = gr.Image(
+                        label="Generated Image", type="filepath")
+                    single_status = gr.Textbox(
+                        label="Status", lines=3, interactive=False)
+
+        # Batch Generation Tab
+        with gr.TabItem("🔄 A/B Testing Batch"):
+            gr.Markdown("""
+                        ### Generate Strategic Variations for Testing
+                        Create different versions that test specific elements to optimize your content performance.
+                        Each variation tests a different hypothesis about what works best for your audience.
+                        """)
+            with gr.Row():
+                with gr.Column():
+                    batch_prompt = gr.Textbox(
+                        label="Base Content Prompt",
+                        placeholder="Describe your core content idea...\nExample: Professional announcement for new product launch",
+                        lines=3
+                    )
+                    batch_variation_type = gr.Dropdown(
+                        choices=[
+                            ("🎨 Mixed Strategy (Recommended)", "mixed"),
+                            ("🌈 Color Psychology Test", "color_schemes"),
+                            ("📐 Layout & Composition Test", "composition_styles"),
+                            ("😊 Emotional Tone Test", "emotional_tones"),
+                            ("📱 Platform Optimization Test", "social_media"),
+                            ("👁️ Attention-Grabbing Test", "engagement_hooks"),
+                            ("🏷️ Brand Positioning Test", "brand_positioning")
+                            ],
+                        value="mixed",
+                        label="Testing Strategy",
+                        info="Choose what aspect you want to test"
+                        )
+                    with gr.Row():
+                        batch_count = gr.Slider(
+                            2, 5, 3,
+                            step=1,
+                            label="Number of Variations",
+                            info="How many different versions to generate"
+                            )
+                        batch_steps = gr.Slider(
+                            10, 100, 40,
+                            label="Quality (Inference Steps)",info="Lower steps for quick testing")
+
+                    batch_btn = gr.Button(
+                        "🔄 Generate Variations", variant="primary", size="lg")
+                    
+                    strategy_info = gr.Markdown("""
+                                                **💡 Current Strategy:** Mixed approach testing multiple variables
+                                                **What this tests:** Different colors, layouts, and styles to find what works best
+                                                **How to use results:** Post each variation and compare engagement metrics
+                                                """)
+
+
+                with gr.Column():
+                    batch_output = gr.Gallery(
+                        label="Generated Test Variations",
+                        columns=2,
+                        height="auto"
+                    )
+                    batch_status = gr.Textbox(
+                        label="Variation Details", lines=6, interactive=False)
+                    with gr.Accordion("📊 A/B Testing Guide",open=False):
+                        gr.Markdown("""
+                                **Step 1:** Generate variations above
+                                **Step 2:** Post each variation to your platform
+                                **Step 3:** Track these metrics for each:
+                                - Engagement rate (likes, comments, shares)
+                                - Click-through rate (if applicable)
+                                - Reach and impressions
+                                - Save/bookmark rate
+                                
+                                **Step 4:** Use the best performer for future content
+                                
+                                **💡 Pro Tips:**
+                                - Test one element at a time for clear results
+                                - Run tests for at least 7 days
+                                - Use the same posting time and hashtags
+                                - Need 1000+ views per variation for statistical significance
+                                """)
+        # Social Media Tab
+        with gr.TabItem("📱 Social Media Pack"):
+            gr.Markdown("""
+            ### Generate Platform-Optimized Images
+            Create perfectly sized images for multiple social media platforms at once.
+            """)
+            with gr.Row():
+                with gr.Column():
+                    social_prompt = gr.Textbox(
+                        label="Content Prompt",
+                        placeholder="Describe your social media content...\nExample: Exciting announcement for new product launch",
+                        lines=3
+                    )
+                    social_platforms = gr.CheckboxGroup(
+                        choices=[
+                            ("Instagram Post (1080x1080)", "instagram_post"),
+                            ("Instagram Story (1080x1920)", "instagram_story"),
+                            ("Twitter Post (1200x675)", "twitter_post"),
+                            ("LinkedIn Post (1200x1200)", "linkedin_post"),
+                            ("Facebook Cover (1200x630)", "facebook_cover"),
+                            ("YouTube Thumbnail (1280x720)", "youtube_thumbnail")
+                        ],
+                        value=["instagram_post", "twitter_post"],
+                        label="Select Platforms",
+                        info="Each platform will get an optimized image"
+                    )
+                    social_steps = gr.Slider(
+                        10, 100, 50,
+                        label="Quality (Inference Steps)"
+                    )
+                    social_btn = gr.Button(
+                        "📱 Generate Social Pack", variant="primary", size="lg")
+
+                with gr.Column():
+                    social_output = gr.Gallery(
+                        label="Platform-Optimized Images",
+                        columns=2,
+                        height="auto"
+                    )
+                    social_status = gr.Textbox(
+                        label="Status", lines=4, interactive=False)
+
+        with gr.TabItem("🤖 AI Prompt Assistant"):
+            # Mobile-friendly header
+            with gr.Column():
+                gr.Markdown("### 🤖 AI-Powered Prompt Creation")
+                with gr.Accordion("💡 How This Works", open=False):
+                    gr.Markdown("""
+                    **Simple 3-step process:**
+                    1. Describe what you want in plain English
+                    2. AI creates an optimized prompt  
+                    3. Generate your professional image
+                    """)
+            
+            # Main content - responsive layout
+            with gr.Row():
+                # Left column - Input section
+                with gr.Column(scale=1, min_width=300):
+                    ai_user_input = gr.Textbox(
+                        label="What do you want to create?",
+                        placeholder="Example: A hero image for my new eco-friendly water bottle product launch",
+                        lines=4,
+                        info="Describe your vision in plain language"
+                    )
+                    
+                    # Mobile-friendly dropdown grid
+                    with gr.Group():
+                        gr.Markdown("#### Settings")
+                        # Stack dropdowns vertically on mobile
+                        ai_context = gr.Dropdown(
+                            choices=[
+                                ("General Marketing", "marketing"),
+                                ("Product Photography", "product"),
+                                ("Social Media Post", "social"),
+                                ("Blog/Article Header", "blog"),
+                                ("Event Promotion", "event"),
+                                ("Brand Identity", "brand")
+                            ],
+                            value="marketing",
+                            label="Content Type",
+                            info="What are you creating?"
+                        )
+                        ai_style = gr.Dropdown(
+                            choices=[
+                                ("Professional", "professional"),
+                                ("Playful & Fun", "playful"),
+                                ("Minimalist", "minimalist"),
+                                ("Luxury", "luxury"),
+                                ("Tech/Modern", "tech"),
+                                ("Natural/Organic", "natural")
+                            ],
+                            value="professional",
+                            label="Style",
+                            info="What mood to convey?"
+                        )
+                        ai_platform = gr.Dropdown(
+                            choices=[
+                                ("General Use", "general"),
+                                ("Instagram", "instagram"),
+                                ("Twitter/X", "twitter"),
+                                ("LinkedIn", "linkedin"),
+                                ("Facebook", "facebook"),
+                                ("Website Hero", "website")
+                            ],
+                            value="general",
+                            label="Platform",
+                            info="Where will this be used?"
+                        )
+                    
+                    # Generate button - full width
+                    ai_generate_btn = gr.Button(
+                        "🤖 Generate AI Prompt", 
+                        variant="primary", 
+                        size="lg",
+                        scale=1
+                    )
+                    
+                    # Quick examples - collapsible on mobile
+                    with gr.Accordion("💭 Example Ideas", open=False):
+                        gr.Examples(
+                            examples=[
+                                ["A hero image for my new eco-friendly water bottle", "product", "natural", "website"],
+                                ["Announcement for our Black Friday sale", "social", "playful", "instagram"],
+                                ["Professional headshots for company about page", "marketing", "professional", "linkedin"],
+                                ["Blog header about AI in marketing", "blog", "tech", "general"],
+                                ["Product showcase for luxury watch collection", "product", "luxury", "instagram"]
+                            ],
+                            inputs=[ai_user_input, ai_context, ai_style, ai_platform],
+                            label=None
+                        )
+
+                # Right column - Output section
+                with gr.Column(scale=1, min_width=300):
+                    ai_generated_prompt = gr.Textbox(
+                        label="AI-Generated Prompt",
+                        lines=6,
+                        interactive=True,
+                        info="Edit this prompt if needed"
+                    )
+                    
+                    ai_status = gr.Textbox(
+                        label="Status",
+                        lines=2,
+                        interactive=False
+                    )
+                    
+                    # Action buttons - stack on mobile
+                    with gr.Row():
+                        ai_use_prompt_btn = gr.Button(
+                            "🎨 Generate Image", 
+                            variant="primary",
+                            scale=2
+                        )
+                        ai_save_prompt_btn = gr.Button(
+                            "💾 Save to Single Tab", 
+                            variant="secondary",
+                            scale=1
+                        )
+                    
+                    # Advanced options - collapsed by default
+                    with gr.Accordion("🔧 Advanced Prompt Refinement", open=False):
+                        ai_improvement_request = gr.Textbox(
+                            label="How to improve this prompt?",
+                            placeholder="Example: Add more dramatic lighting, make it more colorful, include people",
+                            lines=2
+                        )
+                        ai_improve_btn = gr.Button(
+                            "✨ Improve Prompt", 
+                            variant="secondary",
+                            size="sm"
+                        )
+                    
+                    # Preview image
+                    ai_preview_image = gr.Image(
+                        label="Generated Image Preview",
+                        type="filepath",
+                        visible=False,
+                        height=300
+                    )
+            
+            # Bottom tips section - full width
+            with gr.Accordion("🎯 Pro Tips for Better Results", open=False):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("""
+                        **Be Specific About:**
+                        - **Subject**: What's the main focus?
+                        - **Setting**: Where is it happening?
+                        - **Mood**: What feeling to convey?
+                        - **Colors**: Any specific palette?
+                        """)
+                    with gr.Column():
+                        gr.Markdown("""
+                        **Good Examples:**
+                        - ✅ "Minimalist product photo of smartphone on marble"
+                        - ✅ "Vibrant Instagram post for summer sale"
+                        - ❌ "Product photo" (too vague)
+                        - ❌ "Social media post" (not specific)
+                        """)
+
+    # Footer
+    gr.Markdown("""
+    ---
+    ### 🛠️ Powered by:
+    - **Flux AI Model** - State-of-the-art image generation
+    - **Modal Labs** - GPU infrastructure
+    - **MCP Protocol** - Tool integration
+    - **Gradio** - User interface
+    
+    Made with ❤️ for content creators and marketers
+    """)
+
+    # Event handlers
+    single_btn.click(
+        single_image_generation,
+        inputs=[single_prompt, single_steps, single_style],
+        outputs=[single_output, single_status]
+    )
+
+    batch_btn.click(
+        enhanced_batch_generation,
+        inputs=[batch_prompt,batch_variation_type, batch_count, batch_steps],
+        outputs=[batch_output, batch_status]
+    )
+    batch_variation_type.change(
+        update_strategy_info,
+        inputs=[batch_variation_type],
+        outputs=[strategy_info]
+        )
+
+    social_btn.click(
+        social_media_generation,
+        inputs=[social_prompt, social_platforms, social_steps],
+        outputs=[social_output, social_status]
+    )
+
+
+    def generate_ai_prompt(user_input, context, style, platform):
+        """Generate an optimized prompt using AI"""
+        if not marketing_tool.is_connected:
+            return "", "⚠️ MCP Server not connected. Please wait a few seconds and try again."
+
+        if not user_input.strip():
+            return "", "⚠️ Please describe what you want to create."
+
+        try:
+            request_id = f"ai_prompt_{time.time()}"
+            marketing_tool.request_queue.put((
+                "generate_prompt_with_ai",
+                {
+                    "user_input": user_input,
+                    "context": context,
+                    "style": style,
+                    "platform": platform
+                    },
+                request_id
+                ))
+            status, result = wait_for_result(request_id, timeout=60)
+            if status == "success":
+                result_data = json.loads(result)
+                if result_data.get("success"):
+                    return result_data["prompt"], "✅ AI prompt generated successfully!"
+                else:
+                    return result_data.get("fallback_prompt", ""), f"⚠️ Using fallback prompt: {result_data.get('error', 'Unknown error')}"
+            else:
+                return "", f"❌ Error: {result}"
+        except Exception as e:
+            return "", f"❌ Error: {str(e)}"
+    ai_generate_btn.click(
+        generate_ai_prompt,
+        inputs=[ai_user_input, ai_context, ai_style, ai_platform],
+        outputs=[ai_generated_prompt, ai_status]
+    )
+    
+    def improve_ai_prompt(current_prompt, improvement_request):
+        if not marketing_tool.is_connected:
+            return current_prompt, "⚠️ MCP Server not connected."
+        if not current_prompt.strip():
+            return "", "⚠️ No prompt to improve. Generate one first."
+        if not improvement_request.strip():
+            return current_prompt, "⚠️ Please describe how you'd like to improve the prompt."
+        try:
+            enhanced_base = f"{current_prompt}. {improvement_request}"
+            request_id = f"improve_prompt_{time.time()}"
+            marketing_tool.request_queue.put((
+                "enhance_prompt_with_details",  # Use the same tool
+                {
+                    "base_prompt": enhanced_base,
+                    "enhancement_type": "detailed"
+                    },
+                request_id
+                ))
+            status, result = wait_for_result(request_id, timeout=60)
+            if status == "success":
+                if not result:
+                    return current_prompt, "⚠️ Received empty response from server."
+                try:
+                    result_data = json.loads(result)
+                    if result_data.get("success"):
+                        return result_data["enhanced_prompt"], "✅ Prompt improved successfully!"
+                    else:
+                        return current_prompt, f"⚠️ Could not improve prompt: {result_data.get('error', 'Unknown error')}"
+                except json.JSONDecodeError as json_error:
+                    print(f"JSON decode error: {json_error}")
+                    print(f"Raw result: {repr(result)}")
+                    return result if result else current_prompt, "✅ Prompt improved (received as text)!"
+                
+            else:
+                return current_prompt, f"❌ Error: {result}"
+            
+        except Exception as e:
+            print(f"Exception in improve_ai_prompt: {str(e)}")
+            return current_prompt, f"❌ Error: {str(e)}"
+        
+    ai_improve_btn.click(
+        improve_ai_prompt,
+        inputs=[ai_generated_prompt, ai_improvement_request],
+        outputs=[ai_generated_prompt, ai_status]
+    )
+    
+    def generate_image_from_ai_prompt(prompt, show_preview=True):
+        if not prompt.strip():
+            return None, "⚠️ Please generate a prompt first."
+        image_path, status = single_image_generation(prompt, 50, "none")
+        if show_preview and image_path:
+            return gr.update(value=image_path, visible=True), status
+        else:
+            return gr.update(visible=False), status
+        
+    ai_use_prompt_btn.click(
+        lambda prompt: generate_image_from_ai_prompt(prompt, True),
+        inputs=[ai_generated_prompt],
+        outputs=[ai_preview_image, ai_status]
+    )
+    ai_save_prompt_btn.click(
+        lambda prompt: (prompt, "✅ Prompt copied to Single Image tab!"),
+        inputs=[ai_generated_prompt],
+        outputs=[single_prompt, ai_status]
+    ).then(
+        lambda: gr.update(selected="🖼️ Single Image"),
+        outputs=[]
+    )
+
+    # Update connection status
+    def update_connection_status():
+        if marketing_tool.is_connected:
+            return "✅ **Connected to MCP Server** - Ready to generate!"
+        else:
+            return "🔄 Connecting to MCP server... (please wait)"
+
+    # Periodic status update
+    demo.load(update_connection_status, outputs=[connection_status])
+
+if __name__ == "__main__":
+    print("Starting Marketing Content Generator...")
+    print("Please wait for MCP server to initialize...")
+    start_mcp_server()
+    time.sleep(5)
+    print("Launching Gradio interface...")
+    demo.launch(share=False, mcp_server=True)

mcp_server.py

@@ -0,0 +1,639 @@
+import os
+import base64
+import requests
+import asyncio
+import aiohttp
+import json
+from datetime import datetime
+from typing import List, Dict
+import zipfile
+from io import BytesIO
+from PIL import Image
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("modal_flux_testing", timeout=500)
+
+# Configuration
+MODAL_API_URL = "https://rajputvansh4391--flux-api-server-fastapi-server.modal.run"
+# Add Mistral API configuration
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY", "DRdpSRosSmwjj62cbdb3b04xjaPrMKpa")
+MISTRAL_API_URL = "https://api.mistral.ai/v1/chat/completions"
+
+# Social Media Size Presets
+SIZE_PRESETS = {
+    "instagram_post": (1080, 1080),
+    "instagram_story": (1080, 1920),
+    "twitter_post": (1200, 672),
+    "linkedin_post": (1200, 1200),
+    "facebook_cover": (1200, 632),
+    "youtube_thumbnail": (1280, 720),
+}
+
+# Prompt Templates for Marketing
+# Updated Prompt Templates for Cinematic Marketing (based on your examples)
+PROMPT_TEMPLATES = {
+    "product_hero": """A professional, cinematic product photography composition featuring {product} as the center subject against a {background} backdrop. The scene is illuminated with dramatic studio lighting creating golden highlights and deep shadows. The {product} appears to float with ethereal light emanating from beneath, surrounded by subtle glowing particles and atmospheric mist. The composition uses cinematic depth of field with the product razor-sharp in focus while the background fades into artistic bokeh. Luxurious materials and textures are emphasized with photorealistic detail, showcasing premium quality and craftsmanship.""",
+    
+    "social_announcement": """A high-energy, cinematic social media poster announcing {announcement}. The composition features bold, dramatic lighting with vibrant neon glows and electric energy crackling through the frame. Dynamic typography with the announcement text appears in luxurious, impactful metallic font that seems to emerge from the composition. The backdrop features a futuristic cityscape at night with towering skyscrapers surrounded by colorful LED light strips. Atmospheric elements include flowing energy streams, glowing particles, and lens flares that create a sense of excitement and urgency. The entire poster pulses with kinetic energy and modern sophistication.""",
+    
+    "blog_header": """An elegant, cinematic header image for a blog post about {topic}. The composition features ethereal lighting with soft golden hour illumination casting dramatic shadows across the scene. In the foreground, symbolic elements related to {topic} are artistically arranged with professional depth of field. The background dissolves into atmospheric mist with subtle bokeh and floating light particles. The color palette consists of warm golds, deep purples, and rich earth tones. The entire composition exudes intellectual sophistication and visual storytelling, with magazine-quality photography aesthetics.""",
+    
+    "team_photo": """A cinematic corporate team photograph showing {description} in a modern, luxurious office environment. The scene is lit with dramatic architectural lighting, featuring large floor-to-ceiling windows with natural light streaming in, creating beautiful rim lighting around the subjects. The team is positioned dynamically across multiple levels of the space, with some standing and others seated in premium furniture. The background showcases sleek modern architecture with glass, steel, and wood elements. Professional color grading gives the image a premium, magazine-worthy aesthetic with rich contrasts and warm undertones.""",
+    
+    "event_banner": """A spectacular, cinematic event banner for {event} with movie poster-level production value. The composition features epic scale with dramatic perspective and atmospheric depth. Bold, metallic event typography dominates the upper portion with luxurious, impactful font treatment that appears to be forged from light itself. The scene is filled with dynamic elements: swirling energy, floating particles, dramatic spotlights cutting through atmospheric haze, and architectural elements that frame the composition. The color palette uses deep blues, electric purples, and gold accents to create excitement and grandeur.""",
+    
+    "testimonial_bg": """An abstract, cinematic background for testimonial content featuring {mood} aesthetic. The composition uses flowing, organic shapes with ethereal lighting effects creating depth and movement. Subtle geometric patterns emerge from atmospheric mist while soft, diffused lighting creates beautiful gradients across the frame. The scene includes floating elements like delicate particles, soft bokeh, and gentle light rays that add visual interest without overwhelming the testimonial text. The color palette is sophisticated and calming, using gradient transitions between complementary colors to create emotional resonance.""",
+    
+    "poster_style": """A cinematic movie poster composition featuring {subject} with dramatic, high-impact visual storytelling. The scene is dominated by theatrical lighting with bold contrasts between light and shadow. The main subject is positioned using classical composition rules with supporting elements arranged to guide the eye. Atmospheric elements include swirling mist, dramatic sky, glowing magical effects, and rich environmental details. The composition features layered depth with foreground, midground, and background elements all contributing to the narrative. Typography space is reserved for impactful text placement with the overall mood being {mood}.""",
+    
+    "luxury_product": """An ultra-premium product showcase featuring {product} in a luxurious, museum-quality presentation. The item sits on pristine surfaces with perfect reflections, surrounded by architectural elements like marble, gold accents, and crystal. Dramatic lighting creates spectacular highlights and deep shadows, emphasizing every detail and texture. The background features elegant negative space with subtle gradient lighting and floating particles that suggest exclusivity. The entire composition exudes opulence and sophistication, with photorealistic detail that showcases premium craftsmanship and materials."""
+}
+
+# Enhanced Style Modifiers (matching your cinematic examples)
+STYLE_MODIFIERS = {
+    "professional": """professional studio lighting, cinematic composition, dramatic shadows and highlights, premium materials and textures, photorealistic detail, magazine-quality photography, sophisticated color grading, architectural precision, corporate elegance, high-end commercial aesthetics""",
+    
+    "playful": """vibrant neon colors, electric energy crackling through the frame, dynamic movement and flow, glowing particles and magical elements, whimsical floating objects, rainbow light effects, kinetic energy, joyful atmosphere, colorful light strips and LED effects, fun and energetic composition""",
+    
+    "minimalist": """clean geometric composition, pristine white negative space, single dramatic light source, subtle shadows and highlights, elegant simplicity, floating elements with perfect spacing, monochromatic or limited color palette, architectural precision, zen-like tranquility, museum-quality presentation""",
+    
+    "luxury": """opulent materials like gold, marble, and crystal, dramatic chiaroscuro lighting, rich textures and reflections, premium craftsmanship details, sophisticated color palette of deep jewel tones, elegant architectural elements, museum-quality presentation, exclusive atmosphere, metallic accents and flowing fabrics""",
+    
+    "tech": """futuristic neon lighting with electric blue and cyan glows, holographic interfaces and digital elements, sleek metallic surfaces with perfect reflections, floating geometric shapes, matrix-style digital rain effects, cyberpunk aesthetic, glowing circuit patterns, high-tech laboratory environment, innovative and cutting-edge atmosphere""",
+    
+    "cinematic": """movie poster lighting with dramatic spotlights, atmospheric haze and volumetric fog, epic scale and perspective, rich color grading with deep contrasts, cinematic depth of field, theatrical composition, dramatic sky and environmental elements, professional film-quality aesthetics, storytelling through visual elements""",
+    
+    "mystical": """ethereal lighting with soft, magical glows, floating particles and sparkles, misty atmospheric effects, enchanted forest or temple environment, glowing runes and magical symbols, otherworldly color palette of purples and golds, mysterious shadows and light rays, fantasy movie aesthetic, ancient and magical atmosphere""",
+    
+    "editorial": """magazine-quality photography lighting, sophisticated composition following rule of thirds, professional color grading, high fashion aesthetic, dramatic contrasts, premium materials and styling, architectural or natural backgrounds, artistic depth of field, editorial sophistication, contemporary visual storytelling"""
+}
+
+VARIATION_STRATEGIES = {
+    "color_schemes": [
+        "with warm colors (reds, oranges, yellows)",
+        "with cool colors (blues, greens, purples)", 
+        "with bold, high-contrast colors",
+        "with muted, pastel colors",
+        "monochromatic color scheme"
+    ],
+    "composition_styles": [
+        "centered composition with symmetrical balance",
+        "rule of thirds composition with dynamic flow",
+        "minimalist composition with lots of white space",
+        "busy, detailed composition with multiple elements",
+        "close-up, focused composition"
+    ],
+    "emotional_tones": [
+        "energetic and exciting mood",
+        "calm and peaceful atmosphere",
+        "professional and trustworthy feel",
+        "fun and playful vibe",
+        "luxurious and premium aesthetic"
+    ],
+    "visual_styles": [
+        "photorealistic style",
+        "illustrated/graphic design style",
+        "vintage/retro aesthetic",
+        "modern/contemporary look",
+        "artistic/creative approach"
+    ],
+    "lighting_moods": [
+        "bright, well-lit scene",
+        "dramatic lighting with shadows",
+        "soft, diffused lighting",
+        "golden hour warm lighting",
+        "studio lighting setup"
+    ]
+}
+
+# Content creator specific variations
+CONTENT_CREATOR_VARIATIONS = {
+    "social_media": [
+        "Instagram-optimized with bold text overlay space",
+        "TikTok-style with vertical focus and trending elements",
+        "LinkedIn professional with corporate aesthetic",
+        "YouTube thumbnail with clickable visual hierarchy",
+        "Twitter-friendly with clear, readable elements"
+    ],
+    "engagement_hooks": [
+        "with eye-catching focal point in center",
+        "with contrasting element to grab attention",
+        "with human faces or eyes for connection",
+        "with bright colors that pop in feeds",
+        "with intriguing visual question or mystery"
+    ],
+    "brand_positioning": [
+        "premium/luxury brand positioning",
+        "affordable/accessible brand feel",
+        "innovative/cutting-edge brand image",
+        "trustworthy/established brand look",
+        "fun/approachable brand personality"
+    ]
+}
+
+
+# In-memory storage for history (in production, use a database)
+generation_history = []
+
+
+@mcp.tool()
+async def generate_prompt_with_ai(user_input: str, context: str = "marketing", style: str = "professional", platform: str = "general") -> str:
+    """
+    Use Mistral AI to generate optimized prompts for Flux image generation.
+    
+    Args:
+        user_input: What the user wants to create
+        context: The context (marketing, product, social, etc.)
+        style: The desired style
+        platform: Target platform (instagram, twitter, etc.)
+    
+    Returns:
+        An optimized prompt for Flux
+    """
+    try:
+        system_prompt = """You are an expert prompt engineer specializing in creating detailed, cinematic prompts for Flux AI image generation. 
+
+Your prompts should be like movie poster descriptions - highly detailed, vivid, and cinematic. Study these examples:
+
+GOOD EXAMPLES:
+- "minimal poster featuring multiple hands coming out of frame holding a globe as the center subject. there is a miniature world on top of the globe, with happy miniature people and lush green trees. the word 'EARTH' appears above the main subject, with a luxurious, impactful font. the backdrop features a minimalistic galaxy background with glowing stars. the main subject is well lit and the poster is vividly colorful."
+
+- "A high-energy, cinematic movie poster capturing an intense, high-stakes race between Sonic the Hedgehog and a cheetah, set against the vast African savannah at sunset. The poster features bold, dramatic lighting, with the golden glow of the setting sun casting long shadows as both competitors blur across the landscape, dust swirling behind them."
+
+KEY REQUIREMENTS:
+1. Be extremely detailed and descriptive
+2. Include specific lighting details (dramatic lighting, golden glow, well lit, etc.)
+3. Describe the composition and framing
+4. Add cinematic and poster-like qualities
+5. Include color palette descriptions
+6. Mention text placement if relevant
+7. Add atmospheric details (mist, smoke, glowing elements)
+8. Keep under 200 words but pack in maximum detail
+9. Use vivid, cinematic language
+10. Focus on visual storytelling
+
+Generate prompts that sound like professional movie poster or advertisement descriptions."""
+        
+        user_message = f"""Create a detailed, cinematic prompt for Flux AI based on:
+
+User Request: {user_input}
+Context: {context} 
+Style: {style}
+Platform: {platform}
+
+Make it sound like a professional movie poster description with rich visual details, specific lighting, composition, and atmospheric elements. Keep it under 200 words but extremely detailed and vivid."""
+        
+        headers = {
+            "Authorization": f"Bearer {MISTRAL_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": "mistral-large-latest",
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_message}
+            ],
+            "temperature": 0.8,  # Increased for more creativity
+            "max_tokens": 250  # Increased slightly to allow for detailed descriptions
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                MISTRAL_API_URL,
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=30)
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    raise Exception(f"Mistral API error ({response.status}): {error_text}")
+                
+                result = await response.json()
+                generated_prompt = result['choices'][0]['message']['content']
+                
+                # Ensure the prompt is under 200 words
+                word_count = len(generated_prompt.split())
+                if word_count > 200:
+                    # Truncate while preserving sentence structure
+                    words = generated_prompt.split()
+                    truncated = ' '.join(words[:190])
+                    # Find the last complete sentence
+                    last_period = truncated.rfind('.')
+                    if last_period > 100:  # Only truncate if we have a reasonable amount
+                        generated_prompt = truncated[:last_period + 1]
+                
+                return json.dumps({
+                    "success": True,
+                    "prompt": generated_prompt,
+                    "user_input": user_input,
+                    "context": context,
+                    "style": style,
+                    "word_count": len(generated_prompt.split())
+                })
+                
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": str(e),
+            "fallback_prompt": f"Cinematic {style} style image of {user_input}, dramatic lighting, high detail, professional composition, vivid colors"
+        })
+
+# Additional function to improve prompt quality based on your examples
+@mcp.tool()
+async def enhance_prompt_with_details(base_prompt: str, enhancement_type: str = "cinematic") -> str:
+    """
+    Enhance a basic prompt with detailed visual elements like your examples.
+    
+    Args:
+        base_prompt: The basic prompt to enhance
+        enhancement_type: Type of enhancement (cinematic, poster, product, etc.)
+    
+    Returns:
+        Enhanced detailed prompt
+    """
+    try:
+        system_prompt = """You are an expert at enhancing image prompts with rich visual details. Take the basic prompt and transform it into a highly detailed, cinematic description like a movie poster or professional advertisement.
+
+Add elements like:
+- Specific lighting (dramatic, golden glow, well lit, ethereal light)
+- Composition details (center subject, background elements, framing)
+- Atmospheric elements (mist, smoke, glowing stars, dust swirling)
+- Color palette descriptions
+- Texture and material details
+- Cinematic qualities and mood
+- Professional photography/poster qualities
+
+Keep the enhanced prompt under 200 words but extremely detailed."""
+        
+        user_message = f"""Enhance this basic prompt with rich visual details:
+
+Basic Prompt: {base_prompt}
+Enhancement Type: {enhancement_type}
+
+Transform it into a detailed, cinematic description with specific lighting, composition, atmosphere, and visual storytelling elements."""
+        
+        headers = {
+            "Authorization": f"Bearer {MISTRAL_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": "mistral-large-latest",
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_message}
+            ],
+            "temperature": 0.8,
+            "max_tokens": 250
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                MISTRAL_API_URL,
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=30)
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    raise Exception(f"Mistral API error ({response.status}): {error_text}")
+                
+                result = await response.json()
+                enhanced_prompt = result['choices'][0]['message']['content']
+                
+                # Ensure under 200 words
+                word_count = len(enhanced_prompt.split())
+                if word_count > 200:
+                    words = enhanced_prompt.split()
+                    truncated = ' '.join(words[:190])
+                    last_period = truncated.rfind('.')
+                    if last_period > 100:
+                        enhanced_prompt = truncated[:last_period + 1]
+                
+                return json.dumps({
+                    "success": True,
+                    "original_prompt": base_prompt,
+                    "enhanced_prompt": enhanced_prompt,
+                    "word_count": len(enhanced_prompt.split())
+                })
+                
+    except Exception as e:
+        return json.dumps({
+            "success": False,
+            "error": str(e),
+            "original_prompt": base_prompt
+        })
+
+@mcp.tool()
+async def generate_and_save_image(prompt: str, num_inference_steps: int = 50, width: int = 1024, height: int = 1024) -> str:
+    """Generate a single image with specified dimensions"""
+    try:
+        print(f"Sending request to Modal API: {prompt} at {width}x{height}")
+        payload = {
+            "prompt": prompt,
+            "num_inference_steps": num_inference_steps,
+            "width": width,
+            "height": height
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{MODAL_API_URL}/generate",
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=120)
+            ) as response:
+                if response.status != 200:
+                    error_text = await response.text()
+                    raise Exception(f"Modal API error ({response.status}): {error_text}")
+                
+                result = await response.text()
+                result_json = json.loads(result)
+                
+                if 'image_base64' in result_json:
+                    image_b64 = result_json['image_base64']
+                    
+                    # Store in history
+                    generation_history.append({
+                        "prompt": prompt,
+                        "timestamp": datetime.now().isoformat(),
+                        "dimensions": f"{width}x{height}",
+                        "image_base64": image_b64[:100] + "..."  # Store preview only
+                    })
+                    
+                    return image_b64
+                else:
+                    raise Exception("No 'image_base64' key found in response")
+                    
+    except Exception as e:
+        print(f"Error in generate_and_save_image: {str(e)}")
+        raise Exception(f"Error generating image: {str(e)}")
+    
+@mcp.tool()
+async def batch_generate_smart_variations(prompt: str, count: int = 3, variation_type: str = "mixed", num_inference_steps: int = 50, width: int = 1024, height: int = 1024) -> str:
+    """
+    Generate multiple meaningful variations for A/B testing content.
+    
+    variation_type options:
+    - "mixed": Different strategies (recommended for general testing)
+    - "color_schemes": Test different color approaches
+    - "composition_styles": Test different layouts
+    - "emotional_tones": Test different moods
+    - "social_media": Platform-optimized variations
+    - "engagement_hooks": Test attention-grabbing elements
+    - "brand_positioning": Test different brand feels
+    """
+    if count > 5:
+        count = 5
+        
+    variations = []
+    
+    if variation_type == "mixed":
+        # Mix different strategies for comprehensive testing
+        all_variations = []
+        for strategy in VARIATION_STRATEGIES.values():
+            all_variations.extend(strategy[:2])  # Take 2 from each strategy
+        
+        # Add content creator specific ones
+        all_variations.extend(CONTENT_CREATOR_VARIATIONS["engagement_hooks"][:2])
+        
+        # Randomly select variations
+        import random
+        selected_variations = random.sample(all_variations, min(count, len(all_variations)))
+        
+    elif variation_type in VARIATION_STRATEGIES:
+        selected_variations = VARIATION_STRATEGIES[variation_type][:count]
+    elif variation_type in CONTENT_CREATOR_VARIATIONS:
+        selected_variations = CONTENT_CREATOR_VARIATIONS[variation_type][:count]
+    else:
+        # Fallback to mixed
+        selected_variations = [
+            "with vibrant, attention-grabbing colors",
+            "with professional, clean aesthetic", 
+            "with bold, dramatic composition"
+        ][:count]
+    
+    results = []
+    
+    for i, variation in enumerate(selected_variations):
+        enhanced_prompt = f"{prompt}, {variation}"
+        
+        try:
+            print(f"Generating variation {i+1}/{count}: {variation}")
+            image_b64 = await generate_and_save_image(enhanced_prompt, num_inference_steps, width, height)
+            
+            results.append({
+                "index": i,
+                "variation_description": variation,
+                "full_prompt": enhanced_prompt,
+                "dimensions": f"{width}x{height}",
+                "image_base64": image_b64,
+                "testing_purpose": get_testing_purpose(variation)
+            })
+            
+        except Exception as e:
+            print(f"Error generating variation {i+1}: {str(e)}")
+            
+    return json.dumps({
+        "images": results, 
+        "count": len(results),
+        "variation_type": variation_type,
+        "testing_strategy": get_testing_strategy(variation_type)
+    })
+
+def get_testing_purpose(variation: str) -> str:
+    """Get the testing purpose for a variation"""
+    if "warm colors" in variation or "cool colors" in variation:
+        return "Test color psychology impact on engagement"
+    elif "centered" in variation or "rule of thirds" in variation:
+        return "Test composition impact on visual flow"
+    elif "energetic" in variation or "calm" in variation:
+        return "Test emotional response and brand perception"
+    elif "Instagram" in variation or "TikTok" in variation:
+        return "Test platform-specific optimization"
+    elif "premium" in variation or "affordable" in variation:
+        return "Test brand positioning and target audience appeal"
+    elif "eye-catching" in variation or "contrasting" in variation:
+        return "Test attention-grabbing effectiveness"
+    else:
+        return "Test visual style preference"
+
+def get_testing_strategy(variation_type: str) -> str:
+    """Get testing strategy explanation"""
+    strategies = {
+        "mixed": "Comprehensive A/B test across multiple variables to identify best overall approach",
+        "color_schemes": "Test how different colors affect engagement and emotional response",
+        "composition_styles": "Test how layout affects visual hierarchy and user attention",
+        "emotional_tones": "Test which mood resonates best with your target audience",
+        "social_media": "Test platform-specific optimizations for maximum reach",
+        "engagement_hooks": "Test attention-grabbing elements for better click-through rates",
+        "brand_positioning": "Test how different brand feels affect audience perception"
+    }
+    return strategies.get(variation_type, "Test different approaches to optimize content performance")
+
+@mcp.tool()
+async def generate_ab_test_report_template(variations_data: str) -> str:
+    """Generate a template for tracking A/B test results"""
+    import json
+    data = json.loads(variations_data)
+    
+    report_template = {
+        "test_name": "Content Variation A/B Test",
+        "test_date": datetime.now().isoformat(),
+        "variation_type": data.get("variation_type", "mixed"),
+        "testing_strategy": data.get("testing_strategy", ""),
+        "variations": [],
+        "metrics_to_track": [
+            "Impressions",
+            "Engagement Rate (%)",
+            "Click-through Rate (%)",
+            "Saves/Shares",
+            "Comments",
+            "Conversion Rate (%)"
+        ],
+        "recommended_test_duration": "7-14 days for statistical significance",
+        "sample_size_needed": "Minimum 1000 impressions per variation"
+    }
+    
+    for img in data.get("images", []):
+        report_template["variations"].append({
+            "variation_id": f"V{img['index'] + 1}",
+            "description": img["variation_description"],
+            "testing_purpose": img["testing_purpose"],
+            "results": {
+                "impressions": 0,
+                "engagement_rate": 0,
+                "ctr": 0,
+                "saves": 0,
+                "comments": 0,
+                "conversion_rate": 0
+            },
+            "notes": ""
+        })
+    
+    return json.dumps(report_template, indent=2)
+
+
+@mcp.tool()
+async def batch_generate_images(prompt: str, count: int = 3, num_inference_steps: int = 50, width: int = 1024, height: int = 1024) -> str:
+    """
+    Generate multiple images with smart variations for A/B testing.
+    Now uses meaningful variations instead of identical images.
+    """
+    return await batch_generate_smart_variations(
+        prompt=prompt,
+        count=count,
+        variation_type="mixed",
+        num_inference_steps=num_inference_steps,
+        width=width,
+        height=height
+    )
+
+
+@mcp.tool()
+async def generate_social_media_set(prompt: str, platforms: List[str], num_inference_steps: int = 50) -> str:
+    """
+    Generate images optimized for different social media platforms with correct resolutions.
+    Platforms: instagram_post, instagram_story, twitter_post, linkedin_post, etc.
+    """
+    results = []
+    
+    for platform in platforms:
+        if platform in SIZE_PRESETS:
+            width, height = SIZE_PRESETS[platform]
+            platform_prompt = f"{prompt}, optimized for {platform.replace('_', ' ')}"
+            
+            try:
+                # Now pass the actual dimensions to the generation function
+                image_b64 = await generate_and_save_image(
+                    platform_prompt, 
+                    num_inference_steps, 
+                    width, 
+                    height
+                )
+                results.append({
+                    "platform": platform,
+                    "size": [width, height],
+                    "resolution": f"{width}x{height}",
+                    "image_base64": image_b64
+                })
+                print(f"✅ Generated {platform} image at {width}x{height}")
+            except Exception as e:
+                print(f"Error generating for {platform}: {str(e)}")
+                
+    return json.dumps({"results": results})
+
+@mcp.tool() 
+async def add_style_modifier(prompt: str, style: str) -> str:
+    """
+    Add style modifiers to ensure brand consistency.
+    Styles: professional, playful, minimalist, luxury, tech
+    """
+    if style not in STYLE_MODIFIERS:
+        return json.dumps({
+            "error": f"Style '{style}' not found",
+            "available_styles": list(STYLE_MODIFIERS.keys())
+        })
+        
+    enhanced_prompt = f"{prompt}, {STYLE_MODIFIERS[style]}"
+    return json.dumps({
+        "original_prompt": prompt,
+        "enhanced_prompt": enhanced_prompt,
+        "style_applied": style
+    })
+
+@mcp.tool()
+async def get_generation_history(limit: int = 10) -> str:
+    """Get recent generation history for reuse and reference"""
+    recent_history = generation_history[-limit:]
+    return json.dumps({
+        "history": recent_history,
+        "total_generations": len(generation_history)
+    })
+
+@mcp.tool()
+async def create_image_package(image_data_list: List[Dict], package_name: str = "marketing_assets") -> str:
+    """
+    Create a downloadable package of generated images with metadata.
+    Useful for bulk content creation and organization.
+    """
+    # This would create a zip file with images and a metadata JSON
+    # For now, return structured data
+    
+    package_info = {
+        "package_name": package_name,
+        "created_at": datetime.now().isoformat(),
+        "total_images": len(image_data_list),
+        "images": []
+    }
+    
+    for idx, data in enumerate(image_data_list):
+        package_info["images"].append({
+            "filename": f"{package_name}_{idx+1}.png",
+            "prompt": data.get("prompt", ""),
+            "metadata": data.get("metadata", {})
+        })
+        
+    return json.dumps(package_info)
+
+@mcp.tool()
+async def health_check() -> str:
+    """Check if the Modal API server is healthy"""
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{MODAL_API_URL}/health",
+                timeout=aiohttp.ClientTimeout(total=10)
+            ) as response:
+                if response.status == 200:
+                    result = await response.text()
+                    return f"Modal API is healthy: {result}"
+                else:
+                    return f"Modal API returned status {response.status}"
+    except Exception as e:
+        return f"Modal API health check failed: {str(e)}"
+
+if __name__ == "__main__":
+    print("Starting Enhanced MCP server for Content Creators & Marketers...")
+    print(f"Modal API URL: {MODAL_API_URL}")
+    mcp.run(transport="stdio")

requirements.txt

@@ -0,0 +1,18 @@
+gradio[mcp]==5.32.1
+torch>=2.0.0
+torchvision>=0.15.0
+diffusers>=0.24.0
+transformers>=4.35.0
+accelerate>=0.24.0
+safetensors>=0.4.0
+huggingface_hub>=0.19.0
+Pillow>=9.5.0
+requests>=2.31.0
+aiohttp>=3.9.0
+numpy>=1.24.0
+sentencepiece>=0.1.99
+uvicorn
+modal
+modal-client
+fastapi
+nest_asyncio