Merge branch 'main' of https://huggingface.co/spaces/AgentsGuards/agents-guard-mcp

README.md

@@ -1,13 +1,13 @@
 ---
-title: Agents Guard Mcp
-emoji: 🐠
+title: ImageUtilitiesMCP
+emoji: 🖼️
 colorFrom: pink
 colorTo: red
 sdk: gradio
 sdk_version: 5.32.0
-app_file: gradio_interface/app.py
+app_file: app.py
 pinned: false
-short_description: a security  framework designed for MCP deployments.
+short_description: Useful tools for image editing.
 tags: [mcp-server-track]
 ---
 

mcp_server.py → app.py

@@ -4,13 +4,40 @@ from src.utils.remove_background import remove_background
 from src.utils.generate_image import generate_image
 from src.utils.apply_filter import apply_filter
 from src.utils.add_text import add_text_to_image
+from src.utils.add_text import add_text_to_image_base64
+from src.utils.compress import compress_image_memory, compress_image_file
+from src.utils.remove_background import remove_background_from_url
+from src.utils.visualize_image import visualize_base64_image
+from src.utils.generate_image import generate_image
+from src.utils.apply_filter import apply_filter_direct
 from src.utils.watermark import add_watermark, remove_watermark
 from src.utils.describe import describe_image
-from src.utils.compress import compress_image
 import base64
 from PIL import Image
 import io
 import requests
+from io import BytesIO
+from typing import Union
+
+def change_format(image: Union[str, BytesIO], target_format: str) -> str:
+    """
+    Change the format of an image from a URL to the specified target format.
+    """
+    
+    if not isinstance(image, BytesIO):
+        response = requests.get(image, timeout=30)
+        response.raise_for_status()
+        img = Image.open(BytesIO(response.content))
+    else: 
+        img = Image.open(image)
+    
+    output = BytesIO()
+    img.save(output, format=target_format)
+    output.seek(0)
+    
+    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+    
+    return encoded_image
 
 def image_to_base64(image):
     if image is None:
@@ -103,59 +130,93 @@ def gradio_remove_background(image):
 def gradio_describe_image(image):
     if image is None:
         return "No image provided"
-    base64_img = image_to_base64(image)
-    return describe_image(base64_img)
+    try:
+        base64_img = image_to_base64(image)
+        return describe_image(base64_img)
+    except Exception as e:
+        print(f"Error describing image: {e}")
+        return f"Error: {str(e)}"
 
 def gradio_change_format(image, format_type):
     if image is None:
         return None
-    base64_img = image_to_base64(image)
-    result = change_format(base64_img, format_type)
-    return base64_to_image(result)
+    try:
+        base64_img = image_to_base64(image)
+        result = change_format(base64_img, format_type)
+        return base64_to_image(result)
+    except Exception as e:
+        print(f"Error changing format: {e}")
+        return image
 
 def gradio_generate_image(prompt, width=512, height=512):
     result = generate_image(prompt, width, height)
     return base64_to_image(result["b64"])
 
-def gradio_apply_filter(image, filter_type):
+def gradio_apply_filter(image, filter_type, intensity=1.0):
     if image is None:
+        print("No image provided")
         return None
-    base64_img = image_to_base64(image)
-    result = apply_filter(base64_img, filter_type)
-    return base64_to_image(result)
+    
+    return apply_filter_direct(image, filter_type, intensity)
 
-def gradio_add_text(image, text, x=50, y=50, font_size=20, color="white"):
+def update_text_image(image, text, centered, x, y, font_size, color):
     if image is None:
         return None
-    base64_img = image_to_base64(image)
-    result = add_text_to_image(base64_img, text, x, y, font_size, color)
-    return base64_to_image(result)
+    if not text or text.strip() == "":
+        return image
+    
+    result = add_text_to_image_base64(image, text, int(x), int(y), int(font_size), color, centered)
+    return result
+
+def toggle_position_fields(centered):
+    return (
+        gr.Number(interactive=not centered), 
+        gr.Number(interactive=not centered)
+    )
+
+def toggle_intensity_slider(filter_type):
+    intensity_filters = ['blur', 'brightness', 'contrast', 'saturation']
+    return gr.Slider(interactive=filter_type in intensity_filters)
 
 def gradio_add_watermark(image, watermark_text, opacity=0.5):
     if image is None:
         return None
-    base64_img = image_to_base64(image)
-    result = add_watermark(base64_img, watermark_text, opacity)
-    return base64_to_image(result)
+    try:
+        base64_img = image_to_base64(image)
+        result = add_watermark(base64_img, watermark_text, opacity)
+        return base64_to_image(result)
+    except Exception as e:
+        print(f"Error adding watermark: {e}")
+        return image
 
 def gradio_remove_watermark(image):
     if image is None:
         return None
-    base64_img = image_to_base64(image)
-    result = remove_watermark(base64_img)
-    return base64_to_image(result)
+    try:
+        base64_img = image_to_base64(image)
+        result = remove_watermark(base64_img)
+        return base64_to_image(result)
+    except Exception as e:
+        print(f"Error removing watermark: {e}")
+        return image
 
 def gradio_compress_image(image, quality=80):
+    """
+    Compress image for Gradio interface
+    """
     if image is None:
         return None
-    base64_img = image_to_base64(image)
-    result = compress_image(base64_img, quality)
-    return base64_to_image(result)
+    try:
+        compressed_image = compress_image_memory(image, quality, "JPEG")
+        return compressed_image
+    except Exception as e:
+        print(f"Error compressing image: {e}")
+        return image
 
 def create_gradio_interface():
-    with gr.Blocks(title="Image Processing Service", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🖼️ Image Processing Service")
-        gr.Markdown("Servicio completo de procesamiento de imágenes")
+    with gr.Blocks(title="ImageUtilitiesMCP", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🖼️ ImageUtilitiesMCP")
+        gr.Markdown("Complete processing image tools")
         
         with gr.Tabs():
             with gr.Tab("🎨 Generate Image"):
@@ -192,31 +253,89 @@ def create_gradio_interface():
                     filter_input = gr.Image(label="Upload Image", type="pil")
                     with gr.Column():
                         filter_type = gr.Dropdown(
-                            ["blur", "sharpen", "vintage", "black_white", "sepia"],
+                            ["blur", "sharpen", "vintage", "black_white", "sepia", "emboss", "edge", "smooth", "brightness", "contrast", "saturation", "grayscale"],
                             label="Filter Type",
                             value="blur"
                         )
+                        
+                        intensity_slider = gr.Slider(
+                            minimum=0.1,
+                            maximum=300.0,
+                            value=1.0,
+                            step=0.1,
+                            label="Intensity",
+                            interactive=True
+                        )
+                        
                         filter_output = gr.Image(label="Filtered Image")
                 
-                filter_input.change(gradio_apply_filter, [filter_input, filter_type], filter_output)
-                filter_type.change(gradio_apply_filter, [filter_input, filter_type], filter_output)
+                filter_type.change(
+                    toggle_intensity_slider,
+                    filter_type,
+                    intensity_slider
+                )
+                
+                filter_inputs = [filter_input, filter_type, intensity_slider]
+                
+                for inp in filter_inputs:
+                    inp.change(gradio_apply_filter, filter_inputs, filter_output)
             
             with gr.Tab("📝 Add Text"):
                 with gr.Row():
                     text_input = gr.Image(label="Upload Image", type="pil")
                     with gr.Column():
-                        text_content = gr.Textbox(label="Text", placeholder="Enter text to add")
+                        text_content = gr.Textbox(
+                            label="Text", 
+                            placeholder="Enter text to add",
+                            value=""
+                        )
+                        text_centered = gr.Checkbox(label="Center Text", value=False)
+                        
                         with gr.Row():
-                            text_x = gr.Number(label="X Position", value=50)
-                            text_y = gr.Number(label="Y Position", value=50)
+                            text_x = gr.Number(
+                                label="X Position", 
+                                value=50, 
+                                interactive=True,
+                                minimum=0
+                            )
+                            text_y = gr.Number(
+                                label="Y Position", 
+                                value=50, 
+                                interactive=True,
+                                minimum=0
+                            )
+                        
                         with gr.Row():
-                            font_size = gr.Slider(10, 100, 20, label="Font Size")
-                            text_color = gr.ColorPicker(label="Color", value="#FFFFFF")
+                            font_size = gr.Slider(
+                                minimum=10, 
+                                maximum=100, 
+                                value=20, 
+                                label="Font Size"
+                            )
+                            text_color = gr.ColorPicker(
+                                label="Color", 
+                                value="#FFFFFF"
+                            )
+                        
+                        add_text_btn = gr.Button("Add Text", variant="primary")
                         text_output = gr.Image(label="Image with Text")
                 
-                inputs = [text_input, text_content, text_x, text_y, font_size, text_color]
+                text_centered.change(
+                    toggle_position_fields,
+                    text_centered,
+                    [text_x, text_y]
+                )
+                
+                inputs = [text_input, text_content, text_centered, text_x, text_y, font_size, text_color]
+                
+                add_text_btn.click(
+                    update_text_image,
+                    inputs,
+                    text_output
+                )
+                
                 for inp in inputs:
-                    inp.change(gradio_add_text, inputs, text_output)
+                    inp.change(update_text_image, inputs, text_output)
             
             with gr.Tab("💧 Watermark"):
                 with gr.Tabs():
@@ -243,7 +362,7 @@ def create_gradio_interface():
                 with gr.Row():
                     compress_input = gr.Image(label="Upload Image", type="pil")
                     with gr.Column():
-                        quality_slider = gr.Slider(10, 100, 80, label="Quality %")
+                        quality_slider = gr.Slider(0, 100, 80, label="Quality %")
                         compress_output = gr.Image(label="Compressed Image")
                 
                 compress_input.change(gradio_compress_image, [compress_input, quality_slider], compress_output)
@@ -271,8 +390,8 @@ def create_gradio_interface():
 if __name__ == "__main__":
     demo = create_gradio_interface()
     demo.launch(
+        mcp_server=True,
         server_name="0.0.0.0", 
-        server_port=7860, 
-        share=True,
+        server_port=7860,
         show_error=True
     )

src/utils/add_text.py

@@ -2,12 +2,25 @@ from PIL import Image, ImageDraw, ImageFont
 import os
 from typing import Optional, Tuple, Dict, Any
 
-def add_text_to_image(
-    image_path: str,
-    text: str,
-    color: Optional[Tuple[int, int, int]] = None,
-    output_name: Optional[str] = None
-) -> Dict[str, Any]:
+def parse_color(color_str):
+    if color_str.startswith('rgba('):
+        values = color_str[5:-1].split(',')
+        r = int(float(values[0]))
+        g = int(float(values[1]))
+        b = int(float(values[2]))
+        return (r, g, b)
+    elif color_str.startswith('rgb('):
+        values = color_str[4:-1].split(',')
+        r = int(float(values[0]))
+        g = int(float(values[1]))
+        b = int(float(values[2]))
+        return (r, g, b)
+    elif color_str.startswith('#'):
+        return color_str
+    else:
+        return color_str
+
+def add_text_to_image_base64(image, text, x, y, font_size, color, centered=False):
     """
     Adds centered text to an image and saves the result in the same folder.
     If no output_name is provided, '_edited' is appended to the original filename.
@@ -22,47 +35,28 @@ def add_text_to_image(
     Returns:
         Dictionary with success status and info.
     """
+    if image is None:
+        return None
+    
+    img = image.copy()
+    draw = ImageDraw.Draw(img)
+    
     try:
-        if color is None:
-            color = (0, 0, 0)
-
-        image = Image.open(image_path)
-        draw = ImageDraw.Draw(image)
-        font = ImageFont.load_default()
-
-        text_width = draw.textlength(text, font=font)
-        x = (image.width - text_width) / 2
-        y = image.height / 2
-
-        draw.text((x, y), text, fill=color, font=font)
-
-        base_dir = os.path.dirname(image_path)
-        base_name, ext = os.path.splitext(os.path.basename(image_path))
-
-        if output_name:
-            new_filename = f"{output_name}{ext}"
-        else:
-            new_filename = f"{base_name}_edited{ext}"
-
-        new_path = os.path.join(base_dir, new_filename)
-
-        image.save(new_path)
-        output_size = os.path.getsize(new_path)
-
-        return {
-            "success": True,
-            "message": "Text added successfully to the image",
-            "input_path": image_path,
-            "output_path": new_path,
-            "output_size_bytes": output_size,
-            "text": text,
-            "color": color
-        }
-
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-            "input_path": image_path,
-            "output_path": None
-        }
+        font = ImageFont.truetype("arial.ttf", font_size)
+    except:
+        try:
+            font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", font_size)
+        except:
+            font = ImageFont.load_default()
+    
+    parsed_color = parse_color(color)
+    
+    if centered:
+        bbox = draw.textbbox((0, 0), text, font=font)
+        text_width = bbox[2] - bbox[0]
+        text_height = bbox[3] - bbox[1]
+        x = (img.width - text_width) // 2
+        y = (img.height - text_height) // 2
+    
+    draw.text((x, y), text, fill=parsed_color, font=font)
+    return img

src/utils/apply_filter.py

@@ -3,74 +3,100 @@ from io import BytesIO
 import requests
 import base64
 
-def apply_filter(image_url: str, filter_type: str, intensity: float = 1.0, output_format: str = 'JPEG') -> str:
+def apply_filter_direct(image, filter_type, intensity=1.0):
     """
-    Apply various filters to an image from a URL.
-    
-    Args:
-        image_url: The URL of the input image.
-        filter_type: Type of filter to apply ('blur', 'sharpen', 'emboss', 'edge', 'smooth', 
-                    'brightness', 'contrast', 'saturation', 'sepia', 'grayscale').
-        intensity: Filter intensity (0.1 to 3.0, default 1.0).
-        output_format: The desired output format (e.g., 'JPEG', 'PNG').
-        
-    Returns:
-        The filtered image as a base64-encoded string.
+    Apply filters directly to PIL image without base64 conversion
     """
+    if image is None:
+        return None
     
-    response = requests.get(image_url, timeout=30)
-    response.raise_for_status()
+    try:
+        print(f"Applying filter: {filter_type} with intensity: {intensity}")
+        img = image.copy()
+        
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
+        
+        if filter_type == 'blur':
+            img = img.filter(ImageFilter.GaussianBlur(radius=max(0.1, intensity)))
+        elif filter_type == 'sharpen':
+            if intensity <= 1.0:
+                img = img.filter(ImageFilter.SHARPEN)
+            else:
+                img = img.filter(ImageFilter.UnsharpMask(radius=2, percent=int(intensity * 150), threshold=3))
+        elif filter_type == 'emboss':
+            img = img.filter(ImageFilter.EMBOSS)
+        elif filter_type == 'edge':
+            img = img.filter(ImageFilter.FIND_EDGES)
+        elif filter_type == 'smooth':
+            img = img.filter(ImageFilter.SMOOTH_MORE)
+        elif filter_type == 'brightness':
+            enhancer = ImageEnhance.Brightness(img)
+            img = enhancer.enhance(max(0.1, intensity))
+        elif filter_type == 'contrast':
+            enhancer = ImageEnhance.Contrast(img)
+            img = enhancer.enhance(max(0.1, intensity))
+        elif filter_type == 'saturation':
+            enhancer = ImageEnhance.Color(img)
+            img = enhancer.enhance(max(0.1, intensity))
+        elif filter_type == 'sepia':
+            img = apply_sepia_filter_direct(img)
+        elif filter_type == 'grayscale' or filter_type == 'black_white':
+            img = img.convert('L').convert('RGB')
+        elif filter_type == 'vintage':
+            img = apply_vintage_effect_direct(img)
+        else:
+            print(f"Unknown filter type: {filter_type}")
+            return image
+        
+        print(f"Filter applied successfully")
+        return img
+        
+    except Exception as e:
+        print(f"Error applying filter: {e}")
+        import traceback
+        traceback.print_exc()
+        return image
+
+def apply_sepia_filter_direct(img):
+    """Apply sepia tone effect to an image."""
+    width, height = img.size
+    pixels = img.load()
     
-    img = Image.open(BytesIO(response.content))
+    for y in range(height):
+        for x in range(width):
+            r, g, b = pixels[x, y]
+            
+            tr = int(0.393 * r + 0.769 * g + 0.189 * b)
+            tg = int(0.349 * r + 0.686 * g + 0.168 * b)
+            tb = int(0.272 * r + 0.534 * g + 0.131 * b)
+            
+            tr = min(255, tr)
+            tg = min(255, tg)
+            tb = min(255, tb)
+            
+            pixels[x, y] = (tr, tg, tb)
     
-    if img.mode != 'RGB':
-        img = img.convert('RGB')
+    return img
+
+def apply_vintage_effect_direct(img):
+    """Apply a vintage effect combining multiple filters."""
+    contrast_enhancer = ImageEnhance.Contrast(img)
+    img = contrast_enhancer.enhance(0.8)
     
-    if filter_type == 'blur':
-        img = img.filter(ImageFilter.GaussianBlur(radius=intensity))
-    elif filter_type == 'sharpen':
-        img = img.filter(ImageFilter.UnsharpMask(radius=2, percent=int(intensity * 150), threshold=3))
-    elif filter_type == 'emboss':
-        img = img.filter(ImageFilter.EMBOSS)
-    elif filter_type == 'edge':
-        img = img.filter(ImageFilter.FIND_EDGES)
-    elif filter_type == 'smooth':
-        img = img.filter(ImageFilter.SMOOTH_MORE)
-    elif filter_type == 'brightness':
-        enhancer = ImageEnhance.Brightness(img)
-        img = enhancer.enhance(intensity)
-    elif filter_type == 'contrast':
-        enhancer = ImageEnhance.Contrast(img)
-        img = enhancer.enhance(intensity)
-    elif filter_type == 'saturation':
-        enhancer = ImageEnhance.Color(img)
-        img = enhancer.enhance(intensity)
-    elif filter_type == 'sepia':
-        img = apply_sepia_filter(img)
-    elif filter_type == 'grayscale':
-        img = img.convert('L').convert('RGB')
+    brightness_enhancer = ImageEnhance.Brightness(img)
+    img = brightness_enhancer.enhance(1.1)
     
-    output = BytesIO()
-    img.save(output, format=output_format, quality=95)
-    output.seek(0)
+    img = apply_sepia_filter_direct(img)
     
-    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
+    img = img.filter(ImageFilter.GaussianBlur(radius=0.5))
     
-    return encoded_image
+    return img
 
-def apply_sepia_filter(img: Image.Image) -> Image.Image:
-    """
-    Apply sepia tone effect to an image.
-    
-    Args:
-        img: PIL Image object.
-        
-    Returns:
-        Image with sepia effect applied.
-    """
-    
-    pixels = img.load()
+def apply_sepia_filter_direct(img):
+    """Apply sepia tone effect to an image."""
     width, height = img.size
+    pixels = img.load()
     
     for y in range(height):
         for x in range(width):
@@ -80,44 +106,24 @@ def apply_sepia_filter(img: Image.Image) -> Image.Image:
             tg = int(0.349 * r + 0.686 * g + 0.168 * b)
             tb = int(0.272 * r + 0.534 * g + 0.131 * b)
             
-            pixels[x, y] = (min(255, tr), min(255, tg), min(255, tb))
+            tr = min(255, tr)
+            tg = min(255, tg)
+            tb = min(255, tb)
+            
+            pixels[x, y] = (tr, tg, tb)
     
     return img
 
-def apply_vintage_filter(image_url: str, output_format: str = 'JPEG') -> str:
-    """
-    Apply a vintage effect combining multiple filters.
-    
-    Args:
-        image_url: The URL of the input image.
-        output_format: The desired output format.
-        
-    Returns:
-        The vintage-filtered image as a base64-encoded string.
-    """
-    
-    response = requests.get(image_url, timeout=30)
-    response.raise_for_status()
-    
-    img = Image.open(BytesIO(response.content))
-    
-    if img.mode != 'RGB':
-        img = img.convert('RGB')
-    
+def apply_vintage_effect_direct(img):
+    """Apply a vintage effect combining multiple filters."""
     contrast_enhancer = ImageEnhance.Contrast(img)
     img = contrast_enhancer.enhance(0.8)
     
     brightness_enhancer = ImageEnhance.Brightness(img)
     img = brightness_enhancer.enhance(1.1)
     
-    img = apply_sepia_filter(img)
+    img = apply_sepia_filter_direct(img)
     
     img = img.filter(ImageFilter.GaussianBlur(radius=0.5))
     
-    output = BytesIO()
-    img.save(output, format=output_format, quality=90)
-    output.seek(0)
-    
-    encoded_image = base64.b64encode(output.getvalue()).decode('utf-8')
-    
-    return encoded_image
+    return img

src/utils/compress.py

@@ -2,7 +2,7 @@ from PIL import Image
 import os
 from typing import Literal, Optional
 
-def compress_image(
+def compress_image_file(
     input_path: str,
     output_path: str,
     quality: int = 85,
@@ -11,15 +11,7 @@ def compress_image(
     max_height: Optional[int] = None
 ) -> str:
     """
-    Compress an image file.
-    
-    Args:
-        input_path: Path to input image
-        output_path: Path for compressed output
-        quality: Compression quality 1-95 (for JPEG/WEBP)
-        format: Output format
-        max_width: Maximum width (optional)
-        max_height: Maximum height (optional)
+    Compress an image file from disk.
     """
     try:
         if not os.path.splitext(output_path)[1]:
@@ -46,4 +38,22 @@ def compress_image(
         return f"✅ Compressed successfully!\nOriginal: {original_size:.2f}MB → Compressed: {compressed_size:.2f}MB\nReduction: {reduction:.1f}%"
     
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        return f"❌ Error: {str(e)}"
+
+def compress_image_memory(image: Image.Image, quality: int = 80, format: str = "JPEG") -> Image.Image:
+    """
+    Compress an image in memory and return the compressed image.
+    """
+    if format == "JPEG" and image.mode in ("RGBA", "P"):
+        image = image.convert("RGB")
+    
+    output = BytesIO()
+    save_kwargs = {"format": format, "optimize": True}
+    
+    if format in ["JPEG", "WEBP"]:
+        save_kwargs["quality"] = quality
+    
+    image.save(output, **save_kwargs)
+    output.seek(0)
+    
+    return Image.open(output)