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

mcp_server.py

@@ -1,15 +1,18 @@
 from mcp.server.fastmcp import FastMCP
 from src.utils.change_format import change_format
-from src.utils.image_helpers import remove_background_from_url
+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
 from src.utils.add_text import add_text_to_image
 from src.utils.watermark import add_watermark, remove_watermark
+from src.utils.describe import describe_image
+from src.utils.compress import compress_image
 
 mcp = FastMCP("Youtube Service")
 
 mcp.add_tool(remove_background_from_url)
+mcp.add_tool(describe_image)
 mcp.add_tool(change_format)
 mcp.add_tool(visualize_base64_image)
 mcp.add_tool(generate_image)
@@ -17,6 +20,7 @@ mcp.add_tool(apply_filter)
 mcp.add_tool(add_text_to_image)
 mcp.add_tool(add_watermark)
 mcp.add_tool(remove_watermark)
+mcp.add_tool(compress_image)
 
 if __name__ == "__main__":
     mcp.run()

src/utils/compress.py

@@ -0,0 +1,49 @@
+from PIL import Image
+import os
+from typing import Literal, Optional
+
+def compress_image(
+    input_path: str,
+    output_path: str,
+    quality: int = 85,
+    format: Literal["JPEG", "PNG", "WEBP"] = "JPEG",
+    max_width: Optional[int] = None,
+    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)
+    """
+    try:
+        if not os.path.splitext(output_path)[1]:
+            extension_map = {"JPEG": ".jpg", "PNG": ".png", "WEBP": ".webp"}
+            output_path = output_path + extension_map[format]
+        
+        with Image.open(input_path) as img:
+            if format == "JPEG" and img.mode in ("RGBA", "P"):
+                img = img.convert("RGB")
+            
+            if max_width or max_height:
+                img.thumbnail((max_width or img.width, max_height or img.height), Image.Resampling.LANCZOS)
+            
+            save_kwargs = {"format": format, "optimize": True}
+            if format in ["JPEG", "WEBP"]:
+                save_kwargs["quality"] = quality
+            
+            img.save(output_path, **save_kwargs)
+
+        original_size = os.path.getsize(input_path) / 1024 / 1024  
+        compressed_size = os.path.getsize(output_path) / 1024 / 1024 
+        reduction = (1 - compressed_size/original_size) * 100
+        
+        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)}"

src/utils/describe.py

@@ -0,0 +1,109 @@
+import os
+import base64
+import requests
+from pathlib import Path
+from openai import OpenAI
+from urllib.parse import urlparse
+
+def describe_image(image_path: str) -> str:
+    """
+    Generate a description of the image at the given path or URL.
+    
+    Args:
+        image_path: Path to local image file OR URL to image
+    
+    Returns:
+        A string description of the image """
+    
+    # Check if API key is available
+    api_key = os.getenv("NEBIUS_API_KEY")
+    if not api_key:
+        return "Error: NEBIUS_API_KEY environment variable not set"
+    
+    try:
+        # Determine if it's a URL or local file path
+        parsed = urlparse(image_path)
+        is_url = bool(parsed.scheme and parsed.netloc)
+        
+        if is_url:
+            # Handle URL
+            print(f"📡 Downloading image from URL: {image_path}")
+            response = requests.get(image_path, timeout=30)
+            response.raise_for_status()
+            image_data = response.content
+            
+            # Determine content type from response headers
+            content_type = response.headers.get('content-type', '')
+            if 'image' not in content_type:
+                return f"Error: URL does not appear to contain an image. Content-Type: {content_type}"
+                
+        else:
+            # Handle local file
+            image_path = Path(image_path)
+            
+            if not image_path.exists():
+                return f"Error: Local file not found: {image_path}"
+            
+            # Check if it's an image file
+            valid_extensions = {'.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp'}
+            if image_path.suffix.lower() not in valid_extensions:
+                return f"Error: Unsupported file type '{image_path.suffix}'. Supported: {valid_extensions}"
+            
+            print(f"📁 Reading local image: {image_path}")
+            with open(image_path, "rb") as f:
+                image_data = f.read()
+        
+        # Encode image to base64
+        base64_image = base64.b64encode(image_data).decode('utf-8')
+        
+        # Create OpenAI client
+        client = OpenAI(
+            base_url="https://api.studio.nebius.com/v1/",
+            api_key=api_key
+        )  
+        
+        # Make API call with proper vision format
+        response = client.chat.completions.create(
+            model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
+            messages=[
+                {
+                    "role": "system",
+                    "content": "You are a helpful assistant that provides detailed descriptions of images. Focus on the main subjects, colors, composition, and any notable details."
+                },
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Please provide a detailed description of this image."
+                        },
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/jpeg;base64,{base64_image}"
+                            }
+                        }
+                    ]
+                }
+            ],
+            max_tokens=500
+        )
+        
+        description = response.choices[0].message.content.strip()
+        return description
+        
+    except requests.RequestException as e:
+        return f"Error downloading image from URL: {str(e)}"
+    except FileNotFoundError:
+        return f"Error: File not found: {image_path}"
+    except Exception as e:
+        error_msg = str(e)
+        
+        if "vision" in error_msg.lower() or "image" in error_msg.lower():
+            return f"Error: This model may not support vision capabilities. Try a vision-enabled model. Details: {error_msg}"
+        elif "401" in error_msg or "unauthorized" in error_msg.lower():
+            return "Error: Invalid API key or insufficient permissions"
+        elif "rate" in error_msg.lower() or "quota" in error_msg.lower():
+            return f"Error: API rate limit or quota exceeded: {error_msg}"
+        else:
+            return f"Error processing image: {error_msg}"