Add Any2SVG - Image to SVG vectorization with MCP server support

.gitignore

@@ -0,0 +1,19 @@
+# Output
+output/
+*.svg
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+.env
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db

README.md

@@ -1,13 +1,59 @@
----
-title: Any2svg
-emoji: ⚡
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 6.0.1
-app_file: app.py
-pinned: false
-short_description: I need svg stuff for svg things
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Any2SVG - Image to SVG Vectorization Tool
+
+A Gradio 6 application that converts raster images (PNG, JPG, WebP, etc.) to SVG vector graphics. Deployable as a Hugging Face Space and usable as an MCP server.
+
+## Features
+
+- **Multi-format Support**: Accepts PNG, JPG, JPEG, WebP, BMP, GIF, TIFF
+- **High-Quality Vectorization**: Uses vtracer for professional-grade conversion
+- **Configurable Parameters**: Control color mode, path precision, and more
+- **MCP Server Ready**: Built-in MCP server support for AI agent integration
+- **Output Directory Support**: Save SVGs to a configurable output directory
+
+## Installation
+
+```bash
+cd any-to-svg
+pip install -r requirements.txt
+```
+
+## Usage
+
+### As a Web Application
+
+```bash
+python app.py
+```
+
+### As an MCP Server
+
+The app automatically exposes an MCP endpoint at:
+```
+http://localhost:7860/gradio_api/mcp/sse
+```
+
+Add to your MCP client config:
+```json
+{
+  "mcpServers": {
+    "any2svg": {
+      "url": "http://localhost:7860/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+### Environment Variables
+
+- `SVG_OUTPUT_DIR`: Directory to save generated SVG files (default: `./output`)
+- `GRADIO_MCP_SERVER`: Set to `true` to enable MCP server mode
+
+## Deployment to Hugging Face Spaces
+
+1. Create a new Space on Hugging Face
+2. Upload all files from this directory
+3. The Space will automatically start as both a web app and MCP server
+
+## License
+
+MIT

app.py

@@ -0,0 +1,275 @@
+"""
+Any2SVG - Image to SVG Vectorization Tool
+
+A Gradio 6 application that converts raster images to SVG vector graphics.
+Supports MCP server integration for AI agent tool calling.
+
+Purpose: Convert any raster image (PNG, JPG, WebP, etc.) to SVG format
+Inputs: Image file, vectorization parameters
+Outputs: SVG file path or SVG content
+Examples: Logo vectorization, artwork conversion, icon generation
+Edge cases: Very large images, transparent backgrounds, gradients
+Errors: Invalid image format, file I/O errors
+"""
+
+import os
+import sys
+from pathlib import Path
+
+import gradio as gr
+from PIL import Image
+
+# Add dna to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from dna.atoms.vectorizer import (
+    VectorizerConfig,
+    image_to_svg_file,
+    image_to_svg_string,
+    validate_image,
+    VectorizationError,
+    InvalidImageError,
+)
+from dna.molecules.mcp_handler import get_output_directory, process_mcp_request
+
+
+def convert_image_to_svg(
+    image: Image.Image,
+    color_mode: str = "color",
+    filter_speckle: int = 4,
+    color_precision: int = 6,
+    corner_threshold: int = 60,
+    path_precision: int = 3,
+) -> tuple[str, str]:
+    """
+    Convert a raster image to SVG vector graphics.
+
+    Args:
+        image: The input image to convert (PIL Image).
+        color_mode: Vectorization mode - 'color' for full color, 'binary' for black/white.
+        filter_speckle: Remove small artifacts (pixels). Higher = more filtering.
+        color_precision: Color quantization bits (1-8). Lower = fewer colors.
+        corner_threshold: Angle threshold for corner detection (degrees).
+        path_precision: Decimal precision for path coordinates.
+
+    Returns:
+        Tuple of (svg_file_path, svg_content) - path to saved SVG and its content.
+
+    Raises:
+        ValueError: If image is None or invalid.
+        IOError: If file operations fail.
+    """
+    config = VectorizerConfig(
+        color_mode=color_mode,
+        filter_speckle=filter_speckle,
+        color_precision=color_precision,
+        corner_threshold=corner_threshold,
+        path_precision=path_precision,
+    )
+    
+    output_dir = get_output_directory()
+    svg_path = image_to_svg_file(image, output_dir, config=config)
+    
+    with open(svg_path, "r", encoding="utf-8") as f:
+        svg_content = f.read()
+    
+    return str(svg_path), svg_content
+
+
+def process_image(
+    image: Image.Image,
+    color_mode: str,
+    filter_speckle: int,
+    color_precision: int,
+    corner_threshold: int,
+    path_precision: int,
+) -> tuple[str, str, str]:
+    """
+    Process an image and convert it to SVG format.
+
+    Args:
+        image: The input raster image to vectorize.
+        color_mode: 'color' for full color output, 'binary' for black and white.
+        filter_speckle: Speckle filter size to remove small artifacts (1-100).
+        color_precision: Color precision bits for quantization (1-8).
+        corner_threshold: Corner detection angle threshold in degrees (0-180).
+        path_precision: Decimal precision for SVG path coordinates (1-8).
+
+    Returns:
+        Tuple of (status_message, svg_file_path, svg_preview_content).
+    """
+    try:
+        svg_path, svg_content = convert_image_to_svg(
+            image=image,
+            color_mode=color_mode,
+            filter_speckle=filter_speckle,
+            color_precision=color_precision,
+            corner_threshold=corner_threshold,
+            path_precision=path_precision,
+        )
+        
+        status = f"✅ SVG saved to: {svg_path}"
+        return status, svg_path, svg_content
+        
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        return error_msg, "", ""
+
+
+# Build Gradio Interface
+with gr.Blocks(
+    title="Any2SVG - Image to SVG Converter",
+    theme=gr.themes.Soft(),
+) as demo:
+    gr.Markdown(
+        """
+        # 🎨 Any2SVG - Image to SVG Converter
+        
+        Convert raster images (PNG, JPG, WebP, etc.) to scalable vector graphics (SVG).
+        
+        **Features:**
+        - High-quality vectorization using vtracer
+        - Configurable color modes and precision
+        - MCP server support for AI agent integration
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(
+                label="Input Image",
+                type="pil",
+                sources=["upload", "clipboard"],
+            )
+            
+            with gr.Accordion("Vectorization Settings", open=False):
+                color_mode = gr.Radio(
+                    choices=["color", "binary"],
+                    value="color",
+                    label="Color Mode",
+                    info="'color' for full color, 'binary' for black/white",
+                )
+                filter_speckle = gr.Slider(
+                    minimum=1,
+                    maximum=100,
+                    value=4,
+                    step=1,
+                    label="Filter Speckle",
+                    info="Remove small artifacts (higher = more filtering)",
+                )
+                color_precision = gr.Slider(
+                    minimum=1,
+                    maximum=8,
+                    value=6,
+                    step=1,
+                    label="Color Precision",
+                    info="Color quantization bits (lower = fewer colors)",
+                )
+                corner_threshold = gr.Slider(
+                    minimum=0,
+                    maximum=180,
+                    value=60,
+                    step=1,
+                    label="Corner Threshold",
+                    info="Angle threshold for corner detection (degrees)",
+                )
+                path_precision = gr.Slider(
+                    minimum=1,
+                    maximum=8,
+                    value=3,
+                    step=1,
+                    label="Path Precision",
+                    info="Decimal precision for path coordinates",
+                )
+
+            convert_btn = gr.Button("🔄 Convert to SVG", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            status_output = gr.Textbox(
+                label="Status",
+                interactive=False,
+            )
+            svg_file_output = gr.File(
+                label="Download SVG",
+            )
+            svg_preview = gr.Code(
+                label="SVG Preview",
+                language="xml",
+                lines=15,
+            )
+
+    # Event handler
+    convert_btn.click(
+        fn=process_image,
+        inputs=[
+            input_image,
+            color_mode,
+            filter_speckle,
+            color_precision,
+            corner_threshold,
+            path_precision,
+        ],
+        outputs=[status_output, svg_file_output, svg_preview],
+    )
+
+    # Examples
+    gr.Examples(
+        examples=[
+            ["https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png"],
+        ],
+        inputs=[input_image],
+        label="Example Images",
+    )
+
+
+# MCP-only tool for direct conversion
+@gr.api(
+    inputs=[
+        gr.Image(type="pil"),
+        gr.Textbox(value="color"),
+        gr.Number(value=4),
+        gr.Number(value=6),
+    ],
+    outputs=[gr.Textbox(), gr.Textbox()],
+)
+def image_to_svg(
+    image: Image.Image,
+    color_mode: str = "color",
+    filter_speckle: int = 4,
+    color_precision: int = 6,
+) -> tuple[str, str]:
+    """
+    Convert any raster image to SVG vector graphics.
+
+    This tool accepts an image and returns the path to the generated SVG file
+    along with the SVG content. The SVG is saved to the configured output directory.
+
+    Args:
+        image: The input raster image (PNG, JPG, WebP, etc.) to vectorize.
+        color_mode: Vectorization mode - 'color' for full color, 'binary' for B&W.
+        filter_speckle: Speckle filter size (1-100). Higher removes more artifacts.
+        color_precision: Color precision bits (1-8). Lower means fewer colors.
+
+    Returns:
+        Tuple of (svg_file_path, svg_content).
+    """
+    svg_path, svg_content = convert_image_to_svg(
+        image=image,
+        color_mode=color_mode,
+        filter_speckle=int(filter_speckle),
+        color_precision=int(color_precision),
+    )
+    return svg_path, svg_content
+
+
+if __name__ == "__main__":
+    # Ensure output directory exists
+    get_output_directory()
+    
+    # Launch with MCP server enabled
+    demo.launch(
+        mcp_server=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+    )

dna/__init__.py

@@ -0,0 +1,8 @@
+"""
+DNA Architecture - Any2SVG core components.
+
+Layers:
+- atoms: Core utilities, data types, state management
+- molecules: Composite components, deployment scripts
+- proteins: High-level flows and orchestration
+"""

dna/atoms/__init__.py

@@ -0,0 +1,21 @@
+"""
+Atoms - Core utilities and data types for Any2SVG.
+"""
+
+from .vectorizer import (
+    VectorizerConfig,
+    VectorizationError,
+    InvalidImageError,
+    validate_image,
+    image_to_svg_string,
+    image_to_svg_file,
+)
+
+__all__ = [
+    "VectorizerConfig",
+    "VectorizationError",
+    "InvalidImageError",
+    "validate_image",
+    "image_to_svg_string",
+    "image_to_svg_file",
+]

dna/atoms/vectorizer.py

@@ -0,0 +1,182 @@
+"""
+Vectorizer Atom - Core image to SVG conversion utilities.
+
+Purpose: Provide low-level vectorization functions using vtracer
+Inputs: PIL Image, vectorization parameters
+Outputs: SVG content string or file path
+Examples: convert_to_svg(image, colormode="color")
+Edge cases: Transparent images, very large files, corrupted images
+Errors: InvalidImageError, VectorizationError, IOError
+"""
+
+import os
+import tempfile
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import vtracer
+from PIL import Image
+
+
+class VectorizationError(Exception):
+    """Raised when vectorization fails."""
+    pass
+
+
+class InvalidImageError(Exception):
+    """Raised when input image is invalid."""
+    pass
+
+
+@dataclass
+class VectorizerConfig:
+    """Configuration for vectorization parameters."""
+    color_mode: str = "color"  # "color" or "binary"
+    hierarchical: str = "stacked"  # "stacked" or "cutout"
+    filter_speckle: int = 4  # 1-100
+    color_precision: int = 6  # 1-8
+    layer_difference: int = 16
+    corner_threshold: int = 60  # 0-180 degrees
+    length_threshold: float = 4.0
+    max_iterations: int = 10
+    splice_threshold: int = 45  # degrees
+    path_precision: int = 3  # 1-8
+
+    def validate(self) -> None:
+        """Validate configuration parameters."""
+        if self.color_mode not in ("color", "binary"):
+            raise ValueError(f"Invalid color_mode: {self.color_mode}")
+        if self.hierarchical not in ("stacked", "cutout"):
+            raise ValueError(f"Invalid hierarchical: {self.hierarchical}")
+        if not 1 <= self.filter_speckle <= 100:
+            raise ValueError(f"filter_speckle must be 1-100: {self.filter_speckle}")
+        if not 1 <= self.color_precision <= 8:
+            raise ValueError(f"color_precision must be 1-8: {self.color_precision}")
+        if not 0 <= self.corner_threshold <= 180:
+            raise ValueError(f"corner_threshold must be 0-180: {self.corner_threshold}")
+        if not 1 <= self.path_precision <= 8:
+            raise ValueError(f"path_precision must be 1-8: {self.path_precision}")
+
+
+def validate_image(image: Optional[Image.Image]) -> Image.Image:
+    """
+    Validate and prepare image for vectorization.
+    
+    Args:
+        image: PIL Image to validate
+        
+    Returns:
+        Validated PIL Image
+        
+    Raises:
+        InvalidImageError: If image is None or invalid
+    """
+    if image is None:
+        raise InvalidImageError("No image provided")
+    
+    if not isinstance(image, Image.Image):
+        raise InvalidImageError(f"Expected PIL Image, got {type(image)}")
+    
+    # Convert RGBA to RGB with white background if needed for binary mode
+    if image.mode == "RGBA":
+        background = Image.new("RGBA", image.size, (255, 255, 255, 255))
+        background.paste(image, mask=image.split()[3])
+        image = background.convert("RGB")
+    elif image.mode not in ("RGB", "L", "P"):
+        image = image.convert("RGB")
+    
+    return image
+
+
+def image_to_svg_string(
+    image: Image.Image,
+    config: Optional[VectorizerConfig] = None,
+) -> str:
+    """
+    Convert PIL Image to SVG string.
+    
+    Args:
+        image: PIL Image to convert
+        config: Vectorization configuration
+        
+    Returns:
+        SVG content as string
+        
+    Raises:
+        InvalidImageError: If image is invalid
+        VectorizationError: If conversion fails
+    """
+    config = config or VectorizerConfig()
+    config.validate()
+    image = validate_image(image)
+    
+    # Create temp files for vtracer
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_in:
+        input_path = tmp_in.name
+        image.save(input_path, "PNG")
+    
+    with tempfile.NamedTemporaryFile(suffix=".svg", delete=False) as tmp_out:
+        output_path = tmp_out.name
+    
+    try:
+        vtracer.convert_image_to_svg_py(
+            input_path,
+            output_path,
+            colormode=config.color_mode,
+            hierarchical=config.hierarchical,
+            filter_speckle=config.filter_speckle,
+            color_precision=config.color_precision,
+            layer_difference=config.layer_difference,
+            corner_threshold=config.corner_threshold,
+            length_threshold=config.length_threshold,
+            max_iterations=config.max_iterations,
+            splice_threshold=config.splice_threshold,
+            path_precision=config.path_precision,
+        )
+        
+        with open(output_path, "r", encoding="utf-8") as f:
+            return f.read()
+            
+    except Exception as e:
+        raise VectorizationError(f"Vectorization failed: {e}") from e
+        
+    finally:
+        for path in (input_path, output_path):
+            if os.path.exists(path):
+                os.unlink(path)
+
+
+def image_to_svg_file(
+    image: Image.Image,
+    output_dir: Path,
+    filename: Optional[str] = None,
+    config: Optional[VectorizerConfig] = None,
+) -> Path:
+    """
+    Convert PIL Image to SVG file.
+    
+    Args:
+        image: PIL Image to convert
+        output_dir: Directory to save SVG
+        filename: Optional filename (auto-generated if None)
+        config: Vectorization configuration
+        
+    Returns:
+        Path to saved SVG file
+        
+    Raises:
+        InvalidImageError: If image is invalid
+        VectorizationError: If conversion fails
+    """
+    svg_content = image_to_svg_string(image, config)
+    
+    output_dir.mkdir(parents=True, exist_ok=True)
+    filename = filename or f"vectorized_{uuid.uuid4().hex[:8]}.svg"
+    output_path = output_dir / filename
+    
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(svg_content)
+    
+    return output_path

dna/molecules/__init__.py

@@ -0,0 +1,3 @@
+"""
+Molecules - Composite components for Any2SVG.
+"""

dna/molecules/mcp_handler.py

@@ -0,0 +1,84 @@
+"""
+MCP Handler Molecule - MCP server integration for Any2SVG.
+
+Purpose: Handle MCP tool requests and file management
+Inputs: MCP tool calls with image data
+Outputs: SVG file paths and content
+Examples: MCP client calls image_to_svg tool
+Edge cases: Large files, network timeouts, invalid URLs
+Errors: MCPError, FileNotFoundError, NetworkError
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+
+from PIL import Image
+
+from ..atoms.vectorizer import (
+    VectorizerConfig,
+    image_to_svg_file,
+    image_to_svg_string,
+)
+
+
+def get_output_directory() -> Path:
+    """
+    Get the configured SVG output directory.
+    
+    Returns:
+        Path to output directory (created if needed)
+    """
+    output_dir = Path(os.environ.get("SVG_OUTPUT_DIR", "./output"))
+    output_dir.mkdir(parents=True, exist_ok=True)
+    return output_dir
+
+
+def process_mcp_request(
+    image: Image.Image,
+    color_mode: str = "color",
+    filter_speckle: int = 4,
+    color_precision: int = 6,
+    save_to_file: bool = True,
+) -> dict:
+    """
+    Process an MCP tool request for image vectorization.
+    
+    Args:
+        image: PIL Image to convert
+        color_mode: "color" or "binary"
+        filter_speckle: Speckle filter size (1-100)
+        color_precision: Color precision bits (1-8)
+        save_to_file: Whether to save SVG to file
+        
+    Returns:
+        Dict with 'path' (if saved), 'content', and 'success' keys
+    """
+    config = VectorizerConfig(
+        color_mode=color_mode,
+        filter_speckle=filter_speckle,
+        color_precision=color_precision,
+    )
+    
+    result = {"success": False, "path": None, "content": None, "error": None}
+    
+    try:
+        if save_to_file:
+            output_dir = get_output_directory()
+            svg_path = image_to_svg_file(image, output_dir, config=config)
+            
+            with open(svg_path, "r", encoding="utf-8") as f:
+                svg_content = f.read()
+            
+            result["path"] = str(svg_path)
+            result["content"] = svg_content
+        else:
+            result["content"] = image_to_svg_string(image, config)
+        
+        result["success"] = True
+        
+    except Exception as e:
+        result["error"] = str(e)
+    
+    return result

dna/proteins/__init__.py

@@ -0,0 +1,3 @@
+"""
+Proteins - High-level flows and orchestration for Any2SVG.
+"""

knowledge-base/architecture.md

@@ -0,0 +1,55 @@
+# Any2SVG Architecture
+
+## Overview
+
+Any2SVG is a Gradio 6 application that converts raster images to SVG vector graphics. It's designed to work both as a standalone web application and as an MCP (Model Context Protocol) server for AI agent integration.
+
+## DNA Architecture
+
+The project follows the DNA architecture pattern:
+
+```
+any-to-svg/
+├── app.py                    # Main Gradio application
+├── dna/
+│   ├── atoms/               # Core utilities
+│   │   └── vectorizer.py    # Low-level vtracer wrapper
+│   ├── molecules/           # Composite components
+│   │   └── mcp_handler.py   # MCP request processing
+│   └── proteins/            # High-level orchestration
+├── knowledge-base/          # Documentation
+└── output/                  # Generated SVG files
+```
+
+## Components
+
+### Atoms Layer
+- `vectorizer.py`: Core vectorization using vtracer library
+  - `VectorizerConfig`: Configuration dataclass
+  - `image_to_svg_string()`: Convert to SVG string
+  - `image_to_svg_file()`: Convert and save to file
+
+### Molecules Layer
+- `mcp_handler.py`: MCP integration
+  - `process_mcp_request()`: Handle MCP tool calls
+  - `get_output_directory()`: Manage output paths
+
+### Application Layer
+- `app.py`: Gradio interface and MCP server
+  - Web UI with configurable parameters
+  - MCP tool endpoint at `/gradio_api/mcp/sse`
+
+## MCP Integration
+
+The application exposes an MCP tool `image_to_svg` that:
+1. Accepts image input (URL or base64)
+2. Converts to SVG using vtracer
+3. Saves to configured output directory
+4. Returns file path and SVG content
+
+## Security Considerations
+
+- Input validation on all image uploads
+- Sanitized file paths for output
+- Environment variable protection for sensitive config
+- No arbitrary code execution

knowledge-base/mcp-usage.md

@@ -0,0 +1,72 @@
+# MCP Server Usage Guide
+
+## Connecting to Any2SVG MCP Server
+
+### Local Development
+
+When running locally, the MCP server is available at:
+```
+http://localhost:7860/gradio_api/mcp/sse
+```
+
+### Hugging Face Spaces
+
+When deployed to HF Spaces:
+```
+https://YOUR-USERNAME-any2svg.hf.space/gradio_api/mcp/sse
+```
+
+## Client Configuration
+
+### Claude Desktop / Cursor / Cline
+
+Add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "any2svg": {
+      "url": "http://localhost:7860/gradio_api/mcp/sse"
+    }
+  }
+}
+```
+
+### For SSE-incompatible clients (e.g., Claude Desktop)
+
+Use mcp-remote:
+
+```json
+{
+  "mcpServers": {
+    "any2svg": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "http://localhost:7860/gradio_api/mcp/sse"
+      ]
+    }
+  }
+}
+```
+
+## Available Tools
+
+### image_to_svg
+
+Convert any raster image to SVG vector graphics.
+
+**Parameters:**
+- `image` (required): Image URL or base64 data
+- `color_mode` (optional): "color" or "binary" (default: "color")
+- `filter_speckle` (optional): 1-100 (default: 4)
+- `color_precision` (optional): 1-8 (default: 6)
+
+**Returns:**
+- `svg_file_path`: Path to saved SVG file
+- `svg_content`: SVG markup string
+
+## Environment Variables
+
+- `SVG_OUTPUT_DIR`: Directory for saved SVG files (default: `./output`)
+- `GRADIO_MCP_SERVER`: Set to `true` to enable MCP mode

requirements.txt

@@ -0,0 +1,4 @@
+gradio[mcp]>=5.0.0
+vtracer>=0.6.0
+Pillow>=10.0.0
+numpy>=1.24.0