Update app.py

app.py

@@ -1,17 +1,18 @@
 """
-All-in-One Marketing Image Generator with Proper A2A Architecture
-Includes A2A Orchestrator + Agent1 (MCP-Imagen3) + Agent2 (Reviewer) + Gradio Interface
+Marketing Image Generator with Gradio MCP Server
+Professional AI image generation using Google Imagen3 with marketing review
+Deployed on HuggingFace Spaces with built-in MCP server support
 """
 
 import gradio as gr
 import os
 import logging
-import asyncio
 import json
-from typing import Dict, Any
+import base64
+import asyncio
+from typing import Dict, Any, Tuple
 from PIL import Image
 import io
-import base64
 
 # Google Service Account Authentication Setup
 def setup_google_credentials():
@@ -44,29 +45,391 @@ def setup_google_credentials():
 # Setup Google credentials on startup
 setup_google_credentials()
 
-# A2A imports
+# Google AI imports
 try:
-    from a2a_orchestrator import A2AOrchestrator
-    A2A_AVAILABLE = True
+    import google.generativeai as genai
+    from google import genai as genai_sdk
+    GEMINI_AVAILABLE = True
 except ImportError:
-    A2A_AVAILABLE = False
+    GEMINI_AVAILABLE = False
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Initialize A2A Orchestrator
-if A2A_AVAILABLE:
-    orchestrator = A2AOrchestrator()
-    logger.info("✅ A2A Orchestrator initialized")
-else:
-    orchestrator = None
-    logger.warning("⚠️ A2A not available - will use fallback mode")
+# Get API keys - prioritize HuggingFace Secrets
+GCP_KEYS = [
+    # Hugging Face Secrets (these are the primary ones for HF deployment)
+    os.getenv("GOOGLE_API_KEY"),
+    os.getenv("GEMINI_API_KEY"), 
+    os.getenv("GCP_API_KEY"),
+    # Local development keys (fallback for local testing)
+    os.getenv("GCP_KEY_1"),
+    os.getenv("GCP_KEY_2"), 
+    os.getenv("GCP_KEY_3"),
+    os.getenv("GCP_KEY_4"),
+    os.getenv("GCP_KEY_5"),
+    os.getenv("GCP_KEY_6")
+]
+
+GOOGLE_API_KEY = next((key for key in GCP_KEYS if key), None)
+
+if GOOGLE_API_KEY and GEMINI_AVAILABLE:
+    genai.configure(api_key=GOOGLE_API_KEY)
+    logger.info("✅ Google AI configured successfully")
+
+# MCP-enabled functions for Agent1 (Image Generator)
+def enhance_prompt_with_gemini(prompt: str, style: str) -> str:
+    """
+    Use Gemini to enhance the user's prompt for better image generation.
+    
+    Args:
+        prompt (str): The original marketing prompt
+        style (str): The desired image style
+        
+    Returns:
+        str: Enhanced prompt optimized for image generation
+    """
+    if not GEMINI_AVAILABLE or not GOOGLE_API_KEY:
+        # Basic enhancement without Gemini
+        style_enhancers = {
+            "realistic": "photorealistic, high detail, professional photography, sharp focus",
+            "artistic": "artistic masterpiece, creative composition, painterly style",
+            "cartoon": "cartoon style, vibrant colors, playful, animated character design",
+            "photographic": "professional photograph, high quality, detailed, commercial photography",
+            "illustration": "digital illustration, clean vector art, modern design"
+        }
+        enhancer = style_enhancers.get(style.lower(), "high quality, detailed")
+        return f"{prompt}, {enhancer}"
+    
+    try:
+        enhancement_prompt = f"""
+        You are an expert prompt engineer for AI image generation. Take this marketing prompt and enhance it for optimal results.
+
+        Original prompt: "{prompt}"
+        Desired style: "{style}"
+
+        Please provide an enhanced version that:
+        1. Maintains the core marketing intent
+        2. Adds specific technical details for better image quality
+        3. Includes appropriate style descriptors for "{style}" style
+        4. Adds professional marketing composition guidance
+        5. Keeps the enhanced prompt under 150 words
+
+        Return only the enhanced prompt without explanation.
+        """
+        
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        response = model.generate_content(enhancement_prompt)
+        enhanced = response.text.strip()
+        
+        logger.info(f"Gemini enhanced prompt: {enhanced}")
+        return enhanced
+        
+    except Exception as e:
+        logger.warning(f"Failed to enhance prompt with Gemini: {e}")
+        style_enhancers = {
+            "realistic": "photorealistic, high detail, professional photography",
+            "artistic": "artistic masterpiece, creative composition",
+            "cartoon": "cartoon style, vibrant colors, playful",
+            "photographic": "professional photograph, high quality, detailed",
+            "illustration": "digital illustration, clean design"
+        }
+        enhancer = style_enhancers.get(style.lower(), "high quality")
+        return f"{prompt}, {enhancer}"
+
+def generate_marketing_image(prompt: str, style: str = "realistic") -> str:
+    """
+    Generate a professional marketing image using Google Imagen3.
+    
+    Args:
+        prompt (str): Description of the marketing image to generate
+        style (str): Art style for the image (realistic, artistic, cartoon, photographic, illustration)
+        
+    Returns:
+        str: JSON string containing image data and metadata
+    """
+    logger.info(f"🎨 Generating marketing image: {prompt}")
+    
+    try:
+        # Enhance the prompt
+        enhanced_prompt = enhance_prompt_with_gemini(prompt, style)
+        
+        # Try to generate with Google Genai SDK
+        if GEMINI_AVAILABLE and GOOGLE_API_KEY:
+            try:
+                logger.info("🎨 Using Google Genai SDK for image generation")
+                
+                # Initialize the genai SDK client  
+                client = genai_sdk.Client(api_key=GOOGLE_API_KEY)
+                
+                # Generate image using Imagen 3 via SDK
+                result = client.models.generate_images(
+                    model="imagen-3.0-generate-002",
+                    prompt=enhanced_prompt,
+                    config={
+                        "number_of_images": 1,
+                        "output_mime_type": "image/png"
+                    }
+                )
+                
+                # Check if we got a valid response with images
+                if result and hasattr(result, 'generated_images') and len(result.generated_images) > 0:
+                    generated_image = result.generated_images[0]
+                    
+                    if hasattr(generated_image, 'image') and hasattr(generated_image.image, 'image_bytes'):
+                        # Convert image bytes to base64 data URL
+                        image_bytes = generated_image.image.image_bytes
+                        img_base64 = base64.b64encode(image_bytes).decode('utf-8')
+                        
+                        # Determine MIME type from the response or default to PNG
+                        mime_type = getattr(generated_image.image, 'mime_type', 'image/png')
+                        image_url = f"data:{mime_type};base64,{img_base64}"
+                        
+                        response_data = {
+                            "success": True,
+                            "image_url": image_url,
+                            "prompt": prompt,
+                            "enhanced_prompt": enhanced_prompt,
+                            "style": style,
+                            "generation_method": "google-genai-sdk",
+                            "real_ai_generation": True
+                        }
+                        
+                        logger.info("✅ Successfully generated real AI image with Google SDK!")
+                        return json.dumps(response_data)
+                        
+            except Exception as e:
+                logger.error(f"Google SDK generation failed: {e}")
+        
+        # Fallback: Generate a deterministic placeholder
+        logger.info("🔄 Using placeholder URL fallback")
+        prompt_hash = abs(hash(enhanced_prompt)) % 10000
+        image_url = f"https://picsum.photos/seed/{prompt_hash}/1024/1024"
+        
+        response_data = {
+            "success": True,
+            "image_url": image_url,
+            "prompt": prompt,
+            "enhanced_prompt": enhanced_prompt,
+            "style": style,
+            "generation_method": "placeholder",
+            "real_ai_generation": False
+        }
+        
+        return json.dumps(response_data)
+        
+    except Exception as e:
+        logger.error(f"Image generation failed: {e}")
+        return json.dumps({
+            "success": False,
+            "error": f"Generation failed: {str(e)}",
+            "prompt": prompt,
+            "style": style
+        })
 
-def process_generated_image_and_results(api_response):
+def analyze_marketing_prompt(prompt: str, review_guidelines: str = "") -> str:
+    """
+    Analyze a marketing prompt for quality, relevance, and compliance.
+    
+    Args:
+        prompt (str): The marketing prompt to analyze
+        review_guidelines (str): Specific guidelines to check against
+        
+    Returns:
+        str: JSON string containing detailed analysis and recommendations
+    """
+    logger.info(f"🔍 Analyzing marketing prompt: {prompt[:50]}...")
+    
+    try:
+        word_count = len(prompt.split())
+        
+        # Check for marketing-specific elements
+        marketing_keywords = [
+            "professional", "corporate", "business", "marketing", "brand", "commercial",
+            "office", "team", "collaboration", "presentation", "meeting", "workplace",
+            "customer", "service", "product", "showcase", "display", "advertising"
+        ]
+        
+        style_keywords = [
+            "realistic", "photographic", "artistic", "creative", "modern", "clean",
+            "minimalist", "professional", "high-quality", "detailed", "sharp"
+        ]
+        
+        composition_keywords = [
+            "lighting", "composition", "background", "foreground", "perspective",
+            "angle", "framing", "focus", "depth", "contrast", "colors"
+        ]
+        
+        # Count keyword categories
+        marketing_score = sum(1 for word in marketing_keywords if word.lower() in prompt.lower()) / len(marketing_keywords)
+        style_score = sum(1 for word in style_keywords if word.lower() in prompt.lower()) / len(style_keywords)
+        composition_score = sum(1 for word in composition_keywords if word.lower() in prompt.lower()) / len(composition_keywords)
+        
+        # Base quality assessment
+        if word_count < 5:
+            base_quality = 0.3
+            quality_issues = ["Prompt is too short and lacks detail"]
+        elif word_count < 10:
+            base_quality = 0.5
+            quality_issues = ["Prompt could benefit from more descriptive details"]
+        elif word_count < 20:
+            base_quality = 0.7
+            quality_issues = []
+        elif word_count < 40:
+            base_quality = 0.8
+            quality_issues = []
+        else:
+            base_quality = 0.6
+            quality_issues = ["Prompt might be too complex - consider simplifying"]
+        
+        # Adjust based on keyword presence
+        quality_adjustment = (marketing_score * 0.2 + style_score * 0.15 + composition_score * 0.15)
+        final_quality = min(1.0, base_quality + quality_adjustment)
+        
+        # Generate specific feedback
+        missing_elements = []
+        if marketing_score < 0.1:
+            missing_elements.append("marketing context or business relevance")
+        if style_score < 0.1:
+            missing_elements.append("artistic style or visual quality descriptors")
+        if "english" in review_guidelines.lower() and "english" not in prompt.lower():
+            missing_elements.append("English language specification for text/signage")
+        
+        present_elements = []
+        if marketing_score > 0.1:
+            present_elements.append("marketing/business context")
+        if style_score > 0.1:
+            present_elements.append("style descriptors")
+        if composition_score > 0.1:
+            present_elements.append("composition guidance")
+        
+        # Calculate overall scores
+        relevance_score = min(1.0, final_quality + (marketing_score * 0.2))
+        safety_score = 0.95  # Generally high for marketing prompts
+        
+        # Check for potentially problematic content
+        problematic_terms = ["violence", "inappropriate", "offensive", "controversial"]
+        for term in problematic_terms:
+            if term in prompt.lower():
+                safety_score = 0.7
+                break
+        
+        overall_score = (final_quality * 0.4 + relevance_score * 0.4 + safety_score * 0.2)
+        
+        # Generate recommendations
+        recommendations = []
+        
+        if final_quality < 0.6:
+            recommendations.append("Consider adding more descriptive details about the desired image")
+        
+        if marketing_score < 0.1:
+            recommendations.append("Add marketing context (e.g., professional, business, corporate)")
+        
+        if "english" in review_guidelines.lower() and "english" not in prompt.lower():
+            recommendations.append("Add 'English signage' or 'English text' to meet language requirements")
+        
+        if word_count < 10:
+            recommendations.append("Expand prompt with lighting, composition, or environmental details")
+        elif word_count > 50:
+            recommendations.append("Consider simplifying prompt while keeping key elements")
+        
+        if not recommendations:
+            if overall_score > 0.8:
+                recommendations.append("Excellent prompt! Should generate high-quality marketing image")
+            else:
+                recommendations.append("Good prompt foundation - image should meet basic requirements")
+        
+        analysis_result = {
+            "success": True,
+            "quality_score": round(final_quality, 2),
+            "relevance_score": round(relevance_score, 2),
+            "safety_score": round(safety_score, 2),
+            "overall_score": round(overall_score, 2),
+            "word_count": word_count,
+            "missing_elements": missing_elements,
+            "present_elements": present_elements,
+            "recommendations": recommendations[:5],
+            "analysis_method": "prompt_analysis"
+        }
+        
+        return json.dumps(analysis_result)
+        
+    except Exception as e:
+        logger.error(f"Prompt analysis failed: {e}")
+        return json.dumps({
+            "success": False,
+            "error": f"Analysis failed: {str(e)}",
+            "prompt": prompt
+        })
+
+def generate_and_review_marketing_image(prompt: str, style: str = "realistic", review_guidelines: str = "") -> str:
+    """
+    Complete workflow: Generate a marketing image and provide quality review.
+    
+    Args:
+        prompt (str): Description of the marketing image to generate
+        style (str): Art style for the image (realistic, artistic, cartoon, photographic, illustration)
+        review_guidelines (str): Specific guidelines for marketing review
+        
+    Returns:
+        str: JSON string containing image, review, and recommendations
+    """
+    logger.info(f"🎭 Starting complete marketing workflow for: {prompt}")
+    
+    try:
+        # Step 1: Generate the image
+        generation_response = generate_marketing_image(prompt, style)
+        generation_data = json.loads(generation_response)
+        
+        if not generation_data.get("success", False):
+            return generation_response  # Return error
+        
+        # Step 2: Analyze the prompt (marketing review)
+        analysis_response = analyze_marketing_prompt(prompt, review_guidelines)
+        analysis_data = json.loads(analysis_response)
+        
+        # Combine results
+        workflow_result = {
+            "success": True,
+            "image": {
+                "url": generation_data.get("image_url", ""),
+                "data": generation_data.get("image_url", ""),
+                "prompt": prompt,
+                "style": style
+            },
+            "review": {
+                "quality_score": analysis_data.get("overall_score", 0.7),
+                "final_status": "passed" if analysis_data.get("overall_score", 0) > 0.7 else "needs_improvement",
+                "iterations": 1,
+                "passed": analysis_data.get("overall_score", 0) > 0.7,
+                "recommendations": analysis_data.get("recommendations", []),
+                "analysis_details": analysis_data
+            },
+            "metadata": {
+                "generation_method": generation_data.get("generation_method", "unknown"),
+                "real_ai_generation": generation_data.get("real_ai_generation", False),
+                "workflow_type": "gradio_mcp_server"
+            }
+        }
+        
+        logger.info("✅ Complete marketing workflow successful!")
+        return json.dumps(workflow_result)
+        
+    except Exception as e:
+        logger.error(f"Complete workflow failed: {e}")
+        return json.dumps({
+            "success": False,
+            "error": f"Workflow failed: {str(e)}",
+            "prompt": prompt,
+            "style": style
+        })
+
+# Gradio interface functions
+def process_generated_image_and_results(api_response_str: str) -> Tuple[Image.Image, str]:
     """Process API response and return image and review text for Gradio display"""
     try:
-        response_data = api_response
+        response_data = json.loads(api_response_str)
         
         if not response_data.get('success', False):
             return None, f"❌ Generation failed: {response_data.get('error', 'Unknown error')}"
@@ -91,7 +454,6 @@ def process_generated_image_and_results(api_response):
             quality_score = review_data.get('quality_score', 0)
             passed = review_data.get('passed', False)
             final_status = review_data.get('final_status', 'unknown')
-            iterations = review_data.get('iterations', 0)
             recommendations = review_data.get('recommendations', [])
             
             status_emoji = "🟢" if passed else "🔴"
@@ -99,23 +461,19 @@ def process_generated_image_and_results(api_response):
             # Extract metadata about generation method
             metadata = response_data.get('metadata', {})
             generation_method = metadata.get('generation_method', 'unknown')
-            real_ai = metadata.get('real_ai_generation', False)
             
             generation_info = ""
-            if generation_method == "imagen3-mcp":
-                generation_info = "🎨 **Generated with**: Imagen3-MCP (Real AI)\n"
-            elif generation_method == "google-genai-sdk":
-                generation_info = "🎨 **Generated with**: Google Genai SDK (Real AI)\n"
+            if generation_method == "google-genai-sdk":
+                generation_info = "🎨 **Generated with**: Google Imagen3 SDK (Real AI)\n"
             elif generation_method == "placeholder":
                 generation_info = "🎨 **Generated with**: Placeholder (Fallback)\n"
             
-            review_text = f"""**🔍 A2A Marketing Review Results**
+            review_text = f"""**🔍 Marketing Review Results**
 
 {generation_info}
 **Quality Score:** {quality_score:.2f}/1.0
 **Status:** {status_emoji} {final_status.upper()}
-**Iterations:** {iterations}
-**Architecture:** A2A Agent Communication
+**Architecture:** Gradio MCP Server
 
 **💡 Recommendations:**
 """
@@ -125,15 +483,7 @@ def process_generated_image_and_results(api_response):
                     review_text += f"{i}. {rec}\n"
             else:
                 review_text += "• Image meets quality standards\n"
-            
-            # Add workflow history
-            workflow_history = review_data.get('workflow_history', [])
-            if workflow_history and len(workflow_history) > 1:
-                review_text += "\n**📋 A2A Workflow History:**\n"
-                for item in workflow_history:
-                    iteration = item.get('iteration', 'N/A')
-                    score = item.get('review_score', 'N/A')
-                    review_text += f"• Iteration {iteration}: Score {score:.2f}\n"
+                
         else:
             review_text = "⚠️ Review data not available"
         
@@ -142,80 +492,21 @@ def process_generated_image_and_results(api_response):
     except Exception as e:
         return None, f"❌ Error processing results: {str(e)}"
 
-def generate_marketing_image_a2a(prompt, style, max_retries, review_threshold, review_guidelines):
-    """Main function for the Gradio interface using A2A Orchestrator"""
+def gradio_generate_marketing_image(prompt: str, style: str, review_guidelines: str) -> Tuple[Image.Image, str]:
+    """Gradio interface wrapper for complete marketing image generation"""
     if not prompt.strip():
         return None, "⚠️ Please enter a prompt to generate an image."
     
-    if not A2A_AVAILABLE or not orchestrator:
-        return None, "❌ A2A Orchestrator not available. Please check setup."
-    
     try:
-        logger.info(f"🎭 Starting A2A workflow for: {prompt}")
-        
-        # Use the A2A orchestrator to coordinate agents
-        result = asyncio.run(
-            orchestrator.generate_image_with_review(
-                prompt=prompt,
-                style=style,
-                max_retries=max_retries,
-                review_threshold=review_threshold,
-                review_guidelines=review_guidelines
-            )
-        )
-        
-        if result["success"]:
-            image, review_text = process_generated_image_and_results(result)
-            success_message = f"✅ A2A Image generation successful!\n\n{review_text}"
-            return image, success_message
-        else:
-            error_message = f"❌ A2A Generation failed: {result.get('error', 'Unknown error')}"
-            return None, error_message
-            
+        # Use the complete workflow function
+        result_json = generate_and_review_marketing_image(prompt, style, review_guidelines)
+        return process_generated_image_and_results(result_json)
     except Exception as e:
-        error_message = f"❌ A2A Error: {str(e)}"
+        error_message = f"❌ Error: {str(e)}"
         logger.error(error_message)
         return None, error_message
 
-async def check_a2a_agents():
-    """Check if A2A agents are available"""
-    if not orchestrator:
-        return {"agent1": False, "agent2": False, "orchestrator": False}
-    
-    try:
-        health_status = await orchestrator.check_agents_health()
-        health_status["orchestrator"] = True
-        return health_status
-    except Exception as e:
-        logger.error(f"Error checking agent health: {e}")
-        return {"agent1": False, "agent2": False, "orchestrator": False}
-
-def get_a2a_system_status():
-    """Get A2A system status for display"""
-    if not A2A_AVAILABLE:
-        return "**🔧 A2A System Status:**\n\n❌ A2A not available\n⚠️ Install google-a2a to enable A2A functionality"
-    
-    try:
-        health_status = asyncio.run(check_a2a_agents())
-        
-        status_text = "**🔧 A2A System Status:**\n\n"
-        status_text += f"{'✅' if health_status.get('orchestrator', False) else '❌'} A2A Orchestrator\n"
-        status_text += f"{'✅' if health_status.get('agent1', False) else '❌'} Agent1 (Image Generator)\n"
-        status_text += f"{'✅' if health_status.get('agent2', False) else '❌'} Agent2 (Marketing Reviewer)\n"
-        
-        all_healthy = all(health_status.values())
-        if all_healthy:
-            status_text += "\n🎉 All A2A agents are running!"
-        else:
-            status_text += "\n⚠️ Some A2A agents are not responding."
-            status_text += "\nRun: `python a2a_servers.py` to start agents"
-        
-        return status_text
-        
-    except Exception as e:
-        return f"**🔧 A2A System Status:**\n\n❌ Error checking status: {str(e)}"
-
-# Define suggested prompts (same as before)
+# Define suggested prompts
 SUGGESTED_PROMPTS = {
     "Modern office team collaboration": ("A modern office space with diverse professionals collaborating around a sleek conference table, natural lighting, professional attire, English signage visible", "realistic"),
     "Executive boardroom meeting": ("Professional executive boardroom with polished conference table, city skyline view, business documents, English presentations on screens", "realistic"),
@@ -226,12 +517,14 @@ SUGGESTED_PROMPTS = {
 }
 
 # Create Gradio interface
-with gr.Blocks(title="A2A Marketing Image Generator", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Marketing Image Generator MCP", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # 🎨 A2A Marketing Image Generator
-    ### Professional AI image generation with proper A2A agent architecture
+    # 🎨 Marketing Image Generator
+    ### Professional AI image generation with built-in MCP server support
     
-    **Agent1** (MCP-Imagen3) ↔ **A2A** ↔ **Agent2** (Marketing Reviewer) ↔ **A2A** ↔ **Orchestrator**
+    **Gradio MCP Server** → **Google Imagen3** → **Marketing Review** → **Results**
+    
+    *MCP Server available at: `/gradio_api/mcp/sse`*
     """)
     
     with gr.Row():
@@ -255,45 +548,21 @@ with gr.Blocks(title="A2A Marketing Image Generator", theme=gr.themes.Soft()) as
             
             review_guidelines = gr.Textbox(
                 label="🔍 Marketing Review Guidelines (Optional)",
-                placeholder="e.g., All text must be in English only, focus on professional appearance, ensure brand colors are prominent, check accessibility compliance, verify readability",
+                placeholder="e.g., All text must be in English only, focus on professional appearance, ensure brand colors are prominent",
                 lines=3,
-                info="Provide specific marketing guidelines for the Marketing Reviewer to evaluate against your brand standards"
+                info="Provide specific marketing guidelines for review"
             )
             
-            # Advanced settings
-            with gr.Accordion("🔧 Advanced Settings", open=False):
-                max_retries = gr.Slider(
-                    minimum=1,
-                    maximum=5,
-                    value=3,
-                    step=1,
-                    label="Max Retries",
-                    info="Maximum number of retry attempts if generation fails"
-                )
-                
-                review_threshold = gr.Slider(
-                    minimum=0.0,
-                    maximum=1.0,
-                    value=0.8,
-                    step=0.1,
-                    label="Quality Threshold",
-                    info="Minimum quality score required for auto-approval"
-                )
-            
             # Generate button
-            generate_btn = gr.Button("🚀 Generate with A2A Architecture", variant="primary", size="lg")
+            generate_btn = gr.Button("🚀 Generate Marketing Image", variant="primary", size="lg")
             
             # Status
-            gr.Markdown("🔍 **Mode**: A2A Agent-to-Agent Communication")
-            
-            # System status
-            with gr.Accordion("📊 A2A System Status", open=False):
-                status_display = gr.Markdown(get_a2a_system_status())
-                refresh_status_btn = gr.Button("🔄 Refresh A2A Status", size="sm")
+            gr.Markdown("🔍 **Mode**: Gradio MCP Server")
+            gr.Markdown(f"🔑 **API Status**: {'✅ Configured' if GOOGLE_API_KEY else '❌ No API Key'}")
         
         with gr.Column(scale=2):
             # Results display
-            gr.Markdown("### 🖼️ Generated Image & A2A Review")
+            gr.Markdown("### 🖼️ Generated Image & Review")
             
             image_output = gr.Image(
                 label="Generated Marketing Image",
@@ -303,8 +572,8 @@ with gr.Blocks(title="A2A Marketing Image Generator", theme=gr.themes.Soft()) as
             )
             
             review_output = gr.Markdown(
-                value="Click **Generate with A2A Architecture** to create your marketing image using agent-to-agent communication",
-                label="A2A Review Results"
+                value="Click **Generate Marketing Image** to create your marketing image with automated review",
+                label="Marketing Review Results"
             )
     
     # Suggested prompts section
@@ -334,36 +603,25 @@ with gr.Blocks(title="A2A Marketing Image Generator", theme=gr.themes.Soft()) as
     
     # Event handlers
     generate_btn.click(
-        fn=generate_marketing_image_a2a,
-        inputs=[prompt, style, max_retries, review_threshold, review_guidelines],
+        fn=gradio_generate_marketing_image,
+        inputs=[prompt, style, review_guidelines],
         outputs=[image_output, review_output],
         show_progress=True
     )
     
-    refresh_status_btn.click(
-        fn=get_a2a_system_status,
-        outputs=status_display
-    )
-    
     # Footer
     gr.Markdown("""
     ---
     <div style='text-align: center; color: #666; font-size: 0.9rem;'>
-        <p>🎨 A2A Marketing Image Generator | Proper Agent-to-Agent Architecture</p>
-        <p>Agent1 (MCP-Imagen3) + Agent2 (Reviewer) + A2A Orchestrator + Gradio Interface</p>
-        <p>Start agents with: <code>python a2a_servers.py</code></p>
+        <p>🎨 Marketing Image Generator | Gradio MCP Server</p>
+        <p>Image Generation + Marketing Review + MCP API</p>
+        <p>MCP Endpoint: <code>/gradio_api/mcp/sse</code></p>
     </div>
     """)
 
 if __name__ == "__main__":
-    logger.info("🚀 Starting A2A Marketing Image Generator")
-    logger.info(f"🤖 A2A Available: {'✅ Yes' if A2A_AVAILABLE else '❌ No'}")
-    
-    if A2A_AVAILABLE:
-        logger.info("💡 Using proper A2A agent-to-agent communication")
-        logger.info("🔗 Architecture: Gradio → Orchestrator → Agent1 (MCP-Imagen3) → Agent2 (Reviewer)")
-        logger.info("📋 Make sure to start agents: python a2a_servers.py")
-    else:
-        logger.warning("💡 A2A not available - install google-a2a for full functionality")
+    logger.info("🚀 Starting Marketing Image Generator with MCP Server")
+    logger.info(f"🔑 Google AI: {'✅ Configured' if GOOGLE_API_KEY else '❌ No API Key'}")
+    logger.info("🔗 MCP Server will be available at /gradio_api/mcp/sse")
     
-    demo.launch()
+    demo.launch(mcp_server=True)