Create app.py

app.py

@@ -0,0 +1,206 @@
+import gradio as gr
+import PIL.Image as Image
+import io
+import base64
+import json
+from typing import Union
+
+def analyze_image(image: Image.Image) -> str:
+    """
+    Analyze an image and return detailed information about it.
+    
+    Args:
+        image: The image to analyze (can be base64 string or file upload)
+    
+    Returns:
+        str: JSON string with image analysis including dimensions, format, mode, and orientation
+    """
+    if image is None:
+        return json.dumps({"error": "No image provided"})
+    
+    try:
+        # Get image properties
+        width, height = image.size
+        format_type = image.format or "Unknown"
+        mode = image.mode
+        orientation = "Portrait" if height > width else "Landscape" if width > height else "Square"
+        
+        # Calculate aspect ratio
+        aspect_ratio = round(width / height, 2) if height > 0 else 0
+        
+        # Get color information
+        colors = image.getcolors(maxcolors=256*256*256)
+        dominant_colors = len(colors) if colors else "Many"
+        
+        analysis = {
+            "dimensions": {"width": width, "height": height},
+            "format": format_type,
+            "mode": mode,
+            "orientation": orientation,
+            "aspect_ratio": aspect_ratio,
+            "approximate_colors": dominant_colors,
+            "file_info": f"{width}x{height} {format_type} image in {mode} mode"
+        }
+        
+        return json.dumps(analysis, indent=2)
+        
+    except Exception as e:
+        return json.dumps({"error": f"Error analyzing image: {str(e)}"})
+
+def get_image_orientation(image: Image.Image) -> str:
+    """
+    Determine if an image is portrait, landscape, or square.
+    
+    Args:
+        image: The image to check orientation
+    
+    Returns:
+        str: "Portrait", "Landscape", or "Square"
+    """
+    if image is None:
+        return "No image provided"
+    
+    try:
+        width, height = image.size
+        if height > width:
+            return "Portrait"
+        elif width > height:
+            return "Landscape"
+        else:
+            return "Square"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def count_colors(image: Image.Image) -> str:
+    """
+    Count the approximate number of unique colors in an image.
+    
+    Args:
+        image: The image to analyze for color count
+    
+    Returns:
+        str: Description of color count and dominant color information
+    """
+    if image is None:
+        return "No image provided"
+    
+    try:
+        # Convert to RGB if not already
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Get colors (limit to prevent memory issues)
+        colors = image.getcolors(maxcolors=256*256*256)
+        
+        if colors is None:
+            return "Image has more than 16.7 million unique colors"
+        
+        # Sort by frequency
+        colors.sort(key=lambda x: x[0], reverse=True)
+        
+        # Get top 3 colors
+        top_colors = colors[:3]
+        color_info = []
+        
+        for count, color in top_colors:
+            if isinstance(color, tuple) and len(color) >= 3:
+                r, g, b = color[:3]
+                hex_color = f"#{r:02x}{g:02x}{b:02x}"
+                percentage = round((count / sum(c[0] for c in colors)) * 100, 1)
+                color_info.append(f"RGB{color} ({hex_color}) - {percentage}%")
+        
+        result = f"Total unique colors: {len(colors)}\n"
+        result += "Top colors by frequency:\n" + "\n".join(color_info)
+        
+        return result
+        
+    except Exception as e:
+        return f"Error analyzing colors: {str(e)}"
+
+def extract_text_info(image: Image.Image) -> str:
+    """
+    Extract basic information about text-like content in an image.
+    
+    Args:
+        image: The image to analyze for text content
+    
+    Returns:
+        str: Basic information about potential text content
+    """
+    if image is None:
+        return "No image provided"
+    
+    try:
+        # Convert to grayscale for analysis
+        gray = image.convert('L')
+        
+        # Get image statistics
+        extrema = gray.getextrema()
+        
+        # Simple heuristics for text detection
+        contrast = extrema[1] - extrema[0]
+        
+        analysis = {
+            "image_mode": image.mode,
+            "grayscale_range": f"{extrema[0]} to {extrema[1]}",
+            "contrast_level": "High" if contrast > 200 else "Medium" if contrast > 100 else "Low",
+            "potential_text": "Likely contains text" if contrast > 150 else "May contain text" if contrast > 100 else "Unlikely to contain text",
+            "note": "This is a basic analysis. For proper OCR, use specialized text extraction tools."
+        }
+        
+        return json.dumps(analysis, indent=2)
+        
+    except Exception as e:
+        return f"Error analyzing for text: {str(e)}"
+
+# Create the Gradio interface
+with gr.Blocks(title="Image Analysis MCP Server") as demo:
+    gr.Markdown("""
+    # Image Analysis MCP Server
+    
+    This Gradio app serves as an MCP server that can analyze images sent from Claude or other MCP clients.
+    
+    **Available Tools:**
+    - `analyze_image`: Get comprehensive image analysis (dimensions, format, colors, etc.)
+    - `get_image_orientation`: Check if image is portrait, landscape, or square
+    - `count_colors`: Analyze color information and dominant colors
+    - `extract_text_info`: Basic analysis for potential text content
+    
+    **Usage with Claude Desktop:**
+    1. Deploy this to HuggingFace Spaces
+    2. Add the MCP configuration to Claude Desktop
+    3. Send images to Claude and ask it to analyze them using these tools
+    """)
+    
+    # Create interface for each function (these will be exposed as MCP tools)
+    with gr.Tab("Image Analysis"):
+        with gr.Row():
+            img_input1 = gr.Image(type="pil", label="Upload Image")
+            analysis_output = gr.JSON(label="Analysis Result")
+        analyze_btn = gr.Button("Analyze Image")
+        analyze_btn.click(analyze_image, inputs=[img_input1], outputs=[analysis_output])
+    
+    with gr.Tab("Orientation Check"):
+        with gr.Row():
+            img_input2 = gr.Image(type="pil", label="Upload Image")
+            orientation_output = gr.Textbox(label="Orientation")
+        orientation_btn = gr.Button("Check Orientation")
+        orientation_btn.click(get_image_orientation, inputs=[img_input2], outputs=[orientation_output])
+    
+    with gr.Tab("Color Analysis"):
+        with gr.Row():
+            img_input3 = gr.Image(type="pil", label="Upload Image")
+            color_output = gr.Textbox(label="Color Analysis", lines=10)
+        color_btn = gr.Button("Analyze Colors")
+        color_btn.click(count_colors, inputs=[img_input3], outputs=[color_output])
+    
+    with gr.Tab("Text Detection"):
+        with gr.Row():
+            img_input4 = gr.Image(type="pil", label="Upload Image")
+            text_output = gr.JSON(label="Text Analysis")
+        text_btn = gr.Button("Analyze for Text")
+        text_btn.click(extract_text_info, inputs=[img_input4], outputs=[text_output])
+
+if __name__ == "__main__":
+    # Launch with MCP server enabled
+    demo.launch(mcp_server=True, share=True)