Add app files

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.DS_Store

app.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+IPMentor - IPv4 Network Analysis and Subnetting Tutor
+Hugging Face Space Entry Point
+"""
+
+import logging
+import os
+from ipmentor.ui import create_interface
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+logger = logging.getLogger(__name__)
+
+def main():
+    """Main application entry point for Hugging Face Space."""
+    logger.info("Starting IPMentor v1.0.0 for Hugging Face Space")
+    
+    # Create Gradio app
+    app = create_interface()
+    
+    # Launch configuration for Hugging Face Space
+    port = int(os.getenv("GRADIO_SERVER_PORT", 7860))
+    launch_config = {
+        "server_name": "0.0.0.0",
+        "server_port": port,  # Use environment port or default
+        "share": False,
+        "show_error": True,
+        "mcp_server": True,  # Enable MCP for Space
+        "quiet": False
+    }
+    
+    logger.info(f"🌐 Web Interface: Starting on port {port}")
+    logger.info("🤖 MCP Server: Enabled for Hugging Face Space")
+    
+    try:
+        app.launch(**launch_config)
+    except Exception as e:
+        logger.error(f"❌ Error launching app: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()

ipmentor/config.py

@@ -0,0 +1,19 @@
+"""
+Simple configuration for IPMentor.
+"""
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Basic settings
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", 7861))
+DEBUG = os.getenv("DEBUG", "false").lower() == "true"
+MCP_ENABLED = os.getenv("MCP_ENABLED", "true").lower() == "true"
+
+# App info
+APP_NAME = "IPMentor"
+VERSION = "1.0.0"
+DESCRIPTION = "IPv4 network analysis and subnetting tutor"

ipmentor/core.py

@@ -0,0 +1,259 @@
+"""
+Core IPv4 networking functions for IPMentor.
+"""
+
+import ipaddress
+import math
+from typing import Dict, List, Tuple
+
+
+def ip_to_binary(ip_str: str) -> str:
+    """Convert IP address to binary format with dots."""
+    try:
+        ip = ipaddress.IPv4Address(ip_str)
+        binary = format(int(ip), '032b')
+        return f"{binary[:8]}.{binary[8:16]}.{binary[16:24]}.{binary[24:]}"
+    except:
+        return "Invalid IP"
+
+
+def binary_to_ip(binary_str: str) -> str:
+    """Convert binary IP to decimal format."""
+    try:
+        binary_clean = binary_str.replace('.', '').replace(' ', '')
+        if len(binary_clean) != 32 or not all(c in '01' for c in binary_clean):
+            return "Invalid Binary"
+        ip_int = int(binary_clean, 2)
+        return str(ipaddress.IPv4Address(ip_int))
+    except:
+        return "Invalid Binary"
+
+
+def parse_subnet_mask(mask_str: str) -> Tuple[str, int]:
+    """Parse subnet mask from various formats."""
+    mask_str = mask_str.strip()
+    
+    if mask_str.startswith('/'):
+        cidr = int(mask_str[1:])
+    elif '.' in mask_str:
+        mask_ip = ipaddress.IPv4Address(mask_str)
+        cidr = bin(int(mask_ip)).count('1')
+    else:
+        cidr = int(mask_str)
+    
+    if not 0 <= cidr <= 32:
+        raise ValueError("Invalid CIDR")
+    
+    mask_ip = ipaddress.IPv4Network(f"0.0.0.0/{cidr}").netmask
+    return str(mask_ip), cidr
+
+
+def analyze_ip(ip: str, subnet_mask: str) -> Dict:
+    """Analyze IP address with subnet mask."""
+    try:
+        # Handle binary IP
+        if '.' in ip and all(c in '01.' for c in ip.replace('.', '')):
+            ip = binary_to_ip(ip)
+            if ip == "Invalid Binary":
+                raise ValueError("Invalid binary IP")
+        
+        # Parse mask
+        mask_decimal, cidr = parse_subnet_mask(subnet_mask)
+        
+        # Create network
+        network = ipaddress.IPv4Network(f"{ip}/{cidr}", strict=False)
+        
+        # Calculate hosts
+        if cidr < 31:
+            total_hosts = 2 ** (32 - cidr) - 2
+            first_host = str(network.network_address + 1)
+            last_host = str(network.broadcast_address - 1)
+        elif cidr == 31:
+            total_hosts = 2
+            first_host = str(network.network_address)
+            last_host = str(network.broadcast_address)
+        else:
+            total_hosts = 1
+            first_host = str(network.network_address)
+            last_host = str(network.network_address)
+        
+        return {
+            "ip_decimal": ip,
+            "ip_binary": ip_to_binary(ip),
+            "subnet_mask_decimal": mask_decimal,
+            "subnet_mask_binary": ip_to_binary(mask_decimal),
+            "subnet_mask_cidr": f"/{cidr}",
+            "network_address": str(network.network_address),
+            "broadcast_address": str(network.broadcast_address),
+            "first_host": first_host,
+            "last_host": last_host,
+            "total_hosts": total_hosts
+        }
+    
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def calculate_subnets(network: str, number: int, method: str, hosts_list: str = "") -> Dict:
+    """Calculate subnets using different methods."""
+    try:
+        base_network = ipaddress.IPv4Network(network, strict=False)
+        base_cidr = base_network.prefixlen
+        
+        if method == "max_subnets":
+            # Calculate subnets needed
+            bits_needed = math.ceil(math.log2(number))
+            new_cidr = base_cidr + bits_needed
+            
+            if new_cidr > 32:
+                raise ValueError("Too many subnets requested")
+            
+            subnets = list(base_network.subnets(new_prefix=new_cidr))
+            hosts_per_subnet = 2 ** (32 - new_cidr) - 2 if new_cidr < 31 else (2 if new_cidr == 31 else 1)
+            
+            subnet_list = []
+            for i, subnet in enumerate(subnets[:number]):
+                subnet_list.append({
+                    "subnet": str(subnet),
+                    "network": str(subnet.network_address),
+                    "broadcast": str(subnet.broadcast_address),
+                    "first_host": str(subnet.network_address + 1) if hosts_per_subnet > 1 else str(subnet.network_address),
+                    "last_host": str(subnet.broadcast_address - 1) if hosts_per_subnet > 1 else str(subnet.broadcast_address),
+                    "hosts": hosts_per_subnet
+                })
+            
+            return {
+                "method": "Max Subnets",
+                "subnets": subnet_list,
+                "bits_borrowed": bits_needed,
+                "hosts_per_subnet": hosts_per_subnet,
+                "total_subnets": len(subnets)
+            }
+        
+        elif method == "max_hosts_per_subnet":
+            # Calculate CIDR for hosts
+            if number <= 2:
+                bits_for_hosts = 1 if number == 2 else 0
+            else:
+                bits_for_hosts = math.ceil(math.log2(number + 2))
+            
+            new_cidr = 32 - bits_for_hosts
+            
+            if new_cidr < base_cidr:
+                raise ValueError("Too many hosts requested")
+            
+            subnets = list(base_network.subnets(new_prefix=new_cidr))
+            actual_hosts = 2 ** bits_for_hosts - 2 if new_cidr < 31 else (2 if new_cidr == 31 else 1)
+            
+            subnet_list = []
+            for subnet in subnets:
+                subnet_list.append({
+                    "subnet": str(subnet),
+                    "network": str(subnet.network_address),
+                    "broadcast": str(subnet.broadcast_address),
+                    "first_host": str(subnet.network_address + 1) if actual_hosts > 1 else str(subnet.network_address),
+                    "last_host": str(subnet.broadcast_address - 1) if actual_hosts > 1 else str(subnet.broadcast_address),
+                    "hosts": actual_hosts
+                })
+            
+            return {
+                "method": "Max Hosts per Subnet",
+                "subnets": subnet_list,
+                "hosts_per_subnet": actual_hosts,
+                "total_subnets": len(subnets)
+            }
+        
+        elif method == "vlsm":
+            # Parse hosts requirements
+            hosts_requirements = [int(x.strip()) for x in hosts_list.split(',')]
+            
+            if len(hosts_requirements) != number:
+                raise ValueError(f"Need exactly {number} host values")
+            
+            # Sort largest first for optimal allocation
+            sorted_reqs = sorted(enumerate(hosts_requirements), key=lambda x: x[1], reverse=True)
+            
+            subnets = []
+            available_networks = [base_network]
+            
+            for original_idx, hosts_needed in sorted_reqs:
+                # Find required CIDR
+                if hosts_needed == 1:
+                    required_cidr = 32
+                elif hosts_needed == 2:
+                    required_cidr = 31
+                else:
+                    # Calculate bits needed for hosts + network + broadcast
+                    bits_for_hosts = math.ceil(math.log2(hosts_needed + 2))
+                    required_cidr = 32 - bits_for_hosts
+                
+                # Find a suitable available network
+                allocated = False
+                for i, avail_net in enumerate(available_networks):
+                    # Check if we can fit the required subnet in this available network
+                    if required_cidr >= avail_net.prefixlen:
+                        # Allocate the first subnet of the required size
+                        try:
+                            allocated_subnet = list(avail_net.subnets(new_prefix=required_cidr))[0]
+                        except ValueError:
+                            # Cannot create subnet of this size
+                            continue
+                        
+                        # Calculate actual host capacity
+                        if required_cidr == 32:
+                            actual_hosts = 1
+                            first_host = str(allocated_subnet.network_address)
+                            last_host = str(allocated_subnet.network_address)
+                        elif required_cidr == 31:
+                            actual_hosts = 2
+                            first_host = str(allocated_subnet.network_address)
+                            last_host = str(allocated_subnet.broadcast_address)
+                        else:
+                            actual_hosts = 2 ** (32 - required_cidr) - 2
+                            first_host = str(allocated_subnet.network_address + 1)
+                            last_host = str(allocated_subnet.broadcast_address - 1)
+                        
+                        subnets.append({
+                            "subnet": str(allocated_subnet),
+                            "network": str(allocated_subnet.network_address),
+                            "broadcast": str(allocated_subnet.broadcast_address),
+                            "first_host": first_host,
+                            "last_host": last_host,
+                            "hosts": actual_hosts,
+                            "hosts_requested": hosts_needed,
+                            "original_order": original_idx + 1
+                        })
+                        
+                        # Remove the used network
+                        available_networks.pop(i)
+                        
+                        # Add remaining available spaces by splitting the original network
+                        remaining_subnets = []
+                        for subnet in avail_net.subnets(new_prefix=required_cidr):
+                            if subnet != allocated_subnet:
+                                remaining_subnets.append(subnet)
+                        
+                        # Add the remaining subnets back to available networks
+                        available_networks.extend(remaining_subnets)
+                        
+                        allocated = True
+                        break
+                
+                if not allocated:
+                    raise ValueError(f"Cannot allocate subnet for {hosts_needed} hosts")
+            
+            # Sort back to original order
+            subnets.sort(key=lambda x: x["original_order"])
+            
+            return {
+                "method": "VLSM",
+                "subnets": subnets,
+                "total_hosts_requested": sum(hosts_requirements),
+                "total_hosts_allocated": sum(s["hosts"] for s in subnets)
+            }
+        
+        else:
+            raise ValueError("Invalid method")
+    
+    except Exception as e:
+        return {"error": str(e)}

ipmentor/main.py

@@ -0,0 +1,48 @@
+"""
+IPMentor - IPv4 Network Analysis and Subnetting Tutor
+"""
+
+import logging
+from .ui import create_interface
+from .config import HOST, PORT, DEBUG, MCP_ENABLED, APP_NAME, VERSION
+
+# Simple logging setup
+logging.basicConfig(
+    level=logging.INFO if not DEBUG else logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Main application entry point."""
+    logger.info(f"Starting {APP_NAME} v{VERSION}")
+    
+    # Create Gradio app
+    app = create_interface()
+    
+    # Launch configuration
+    launch_config = {
+        "server_name": HOST,
+        "server_port": PORT,
+        "share": False,
+        "show_error": DEBUG,
+        "mcp_server": MCP_ENABLED,
+        "quiet": not DEBUG
+    }
+    
+    logger.info(f"🌐 Web Interface: http://{HOST}:{PORT}")
+    if MCP_ENABLED:
+        logger.info(f"🤖 MCP Server: http://{HOST}:{PORT}/gradio_api/mcp/sse")
+    
+    try:
+        app.launch(**launch_config)
+    except KeyboardInterrupt:
+        logger.info("👋 Shutting down...")
+    except Exception as e:
+        logger.error(f"❌ Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

ipmentor/tools.py

@@ -0,0 +1,270 @@
+"""
+MCP tools for IPMentor.
+"""
+
+import json
+import re
+import subprocess
+import tempfile
+import shutil
+import os
+from pathlib import Path
+from typing import List
+from .core import analyze_ip, calculate_subnets
+
+
+def ip_info(ip: str, subnet_mask: str) -> str:
+    """
+    Analyze a complete IPv4 address with its subnet mask.
+
+    Args:
+        ip (str): IP address in decimal (192.168.1.10) or binary format
+        subnet_mask (str): Subnet mask in decimal (255.255.255.0), CIDR (/24), or number (24) format
+
+    Returns:
+        str: Complete IP and network information in JSON format
+    """
+    try:
+        result = analyze_ip(ip.strip(), subnet_mask.strip())
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+def subnet_calculator(network: str, number: str, division_type: str, hosts_per_subnet: str = "") -> str:
+    """
+    Calculate subnets using different division methods.
+
+    Args:
+        network (str): Main network in CIDR format (e.g., "192.168.1.0/24")
+        number (str): Number for division calculation
+        division_type (str): Division method - "max_subnets", "max_hosts_per_subnet", or "vlsm"
+        hosts_per_subnet (str): Comma-separated host counts per subnet (VLSM only)
+
+    Returns:
+        str: Calculated subnet information in JSON format
+    """
+    try:
+        number_int = int(number.strip())
+        result = calculate_subnets(
+            network.strip(), 
+            number_int, 
+            division_type.strip(), 
+            hosts_per_subnet.strip()
+        )
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+# Diagram generation constants and functions
+ICON_MAP = {
+    "Cloud":  "https://davidlms.github.io/ipmentor/assets/cloud.svg",
+    "Router": "https://davidlms.github.io/ipmentor/assets/router.svg",
+    "Switch": "https://davidlms.github.io/ipmentor/assets/switch.svg",
+    "Hosts":  "https://davidlms.github.io/ipmentor/assets/host.svg",
+}
+
+EDGE_STYLE_BASE = (
+    '  style: {\n'
+    '    stroke: "#FFA201"\n'
+    '    stroke-width: 3\n'
+)
+
+
+def _generate_basic_d2_diagram(network_ip: str, hosts_per_subnet: List[int]) -> str:
+    """Generate basic D2 diagram without styling."""
+    lines = [
+        "Internet: Cloud",
+        "Router: Router",
+        "Switch_0: Switch",
+        "",
+        "Internet -> Router",
+        f'Router -> Switch_0: "{network_ip}"',
+        ""
+    ]
+    for idx, hosts in enumerate(hosts_per_subnet, start=1):
+        lines += [
+            f"Switch_{idx}: Switch",
+            f"Host_{idx}: Hosts",
+            f"Switch_0 -> Switch_{idx}",
+            f'Switch_{idx} -> Host_{idx}: "{hosts} hosts"',
+            ""
+        ]
+    if lines[-1] == "":
+        lines.pop()
+    return "\n".join(lines)
+
+
+def _style_d2_diagram(diagram: str) -> str:
+    """Add styling and icons to D2 diagram."""
+    styled = []
+    for line in diagram.splitlines():
+
+        if not line.strip():
+            styled.append("")
+            continue
+
+        # Nodes
+        node_match = re.match(r'^(\w+(?:_\d+)?):\s*(Cloud|Router|Switch|Hosts)\s*$', line.strip())
+        if node_match:
+            name, kind = node_match.groups()
+            styled.append(
+                f"{name}: {kind} {{\n"
+                "  style: {\n"
+                "    font-color: transparent\n"
+                "  }\n"
+                "  shape: image\n"
+                f"  icon: {ICON_MAP[kind]}\n"
+                "}"
+            )
+            continue
+
+        # Edges with labels
+        edge_with_label_match = re.match(r'^(\w+(?:_\d+)?) -> (\w+(?:_\d+)?):\s*"([^"]+)"$', line.strip())
+        if edge_with_label_match:
+            src, dst, label = edge_with_label_match.groups()
+            styled.append(
+                f'{src} -> {dst}: "{label}" {{\n'
+                f"{EDGE_STYLE_BASE}"
+                "    font-size: 30\n"
+                "  }\n"
+                "}"
+            )
+            continue
+
+        # Edges without labels
+        edge_match = re.match(r'^(\w+(?:_\d+)?) -> (\w+(?:_\d+)?)$', line.strip())
+        if edge_match:
+            src, dst = edge_match.groups()
+            styled.append(
+                f"{src} -> {dst}: {{\n"
+                f"{EDGE_STYLE_BASE}"
+                "  }\n"
+                "}"
+            )
+            continue
+
+        styled.append(line)
+
+    return "\n".join(styled)
+
+
+def _export_to_svg(d2_diagram: str, output_path: str | Path = "diagram.svg") -> Path:
+    """Export D2 diagram to SVG using d2 CLI."""
+    if shutil.which("d2") is None:
+        raise RuntimeError(
+            "D2 executable not found.\n"
+            "Install it from https://d2lang.com/tour/installation "
+            "or with Homebrew / chocolatey / scoop."
+        )
+
+    output_path = Path(output_path).expanduser().resolve()
+
+    with tempfile.NamedTemporaryFile("w+", suffix=".d2", delete=False) as tmp:
+        tmp.write(d2_diagram)
+        tmp.flush()
+        tmp_path = Path(tmp.name)
+
+    try:
+        cmd = ["d2", str(tmp_path), str(output_path)]
+        subprocess.run(cmd, check=True)
+    finally:
+        if tmp_path.exists():
+            os.remove(tmp_path)
+
+    return output_path
+
+
+def generate_diagram(ip_network: str, hosts_list: str) -> str:
+    """
+    Generate a network diagram in SVG format for Gradio UI.
+
+    Args:
+        ip_network (str): Network IP with mask in CIDR format (e.g., "192.168.1.0/24")
+        hosts_list (str): Comma-separated list of host counts per subnet (e.g., "50,20,10,5")
+
+    Returns:
+        str: Path to the generated SVG file for Gradio Image component
+    """
+    try:
+        # Parse hosts list
+        hosts_per_subnet = [int(h.strip()) for h in hosts_list.split(",") if h.strip()]
+        
+        if not hosts_per_subnet:
+            raise ValueError("No valid host counts provided")
+
+        # Generate basic diagram
+        base_diagram = _generate_basic_d2_diagram(ip_network.strip(), hosts_per_subnet)
+        
+        # Add styling
+        styled_diagram = _style_d2_diagram(base_diagram)
+        
+        # Export to SVG
+        output_path = _export_to_svg(styled_diagram, "network_diagram.svg")
+        
+        return str(output_path)
+        
+    except Exception as e:
+        # Create a simple error diagram for Gradio to display
+        error_diagram = f"""
+Internet: Cloud {{
+  style: {{
+    font-color: red
+  }}
+}}
+Error: Error occurred: {str(e)[:50]}... {{
+  style: {{
+    font-color: red
+    font-size: 20
+  }}
+}}
+Internet -> Error
+"""
+        try:
+            error_path = _export_to_svg(error_diagram, "error_diagram.svg")
+            return str(error_path)
+        except:
+            # If even error diagram fails, return None
+            return None
+
+
+def generate_diagram_mcp(ip_network: str, hosts_list: str) -> str:
+    """
+    Generate a network diagram in SVG format for MCP API.
+
+    Args:
+        ip_network (str): Network IP with mask in CIDR format (e.g., "192.168.1.0/24")
+        hosts_list (str): Comma-separated list of host counts per subnet (e.g., "50,20,10,5")
+
+    Returns:
+        str: Result information in JSON format including SVG path or error
+    """
+    try:
+        # Parse hosts list
+        hosts_per_subnet = [int(h.strip()) for h in hosts_list.split(",") if h.strip()]
+        
+        if not hosts_per_subnet:
+            return json.dumps({"error": "No valid host counts provided"}, indent=2)
+
+        # Generate basic diagram
+        base_diagram = _generate_basic_d2_diagram(ip_network.strip(), hosts_per_subnet)
+        
+        # Add styling
+        styled_diagram = _style_d2_diagram(base_diagram)
+        
+        # Export to SVG
+        output_path = _export_to_svg(styled_diagram, "network_diagram.svg")
+        
+        result = {
+            "success": True,
+            "svg_path": str(output_path),
+            "network": ip_network.strip(),
+            "hosts_per_subnet": hosts_per_subnet,
+            "d2_diagram": styled_diagram
+        }
+        
+        return json.dumps(result, indent=2)
+        
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)

ipmentor/ui.py

@@ -0,0 +1,127 @@
+"""
+Gradio UI for IPMentor.
+"""
+
+import gradio as gr
+import json
+from .core import analyze_ip, calculate_subnets
+from .tools import generate_diagram, generate_diagram_mcp
+from .config import APP_NAME
+
+
+
+
+# MCP Tool Functions
+def ip_info(ip: str, subnet_mask: str) -> str:
+    """
+    Analyze a complete IPv4 address with its subnet mask.
+    
+    Args:
+        ip (str): IP address in decimal (192.168.1.10) or binary format
+        subnet_mask (str): Subnet mask in decimal (255.255.255.0), CIDR (/24), or number (24) format
+    
+    Returns:
+        str: Complete IP and network information in JSON format
+    """
+    try:
+        result = analyze_ip(ip.strip(), subnet_mask.strip())
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+def subnet_calculator(network: str, number: str, division_type: str, hosts_per_subnet: str = "") -> str:
+    """
+    Calculate subnets using different division methods.
+    
+    Args:
+        network (str): Main network in CIDR format (e.g., "192.168.1.0/24")
+        number (str): Number for division calculation
+        division_type (str): Division method - "max_subnets", "max_hosts_per_subnet", or "vlsm"
+        hosts_per_subnet (str): Comma-separated host counts per subnet (VLSM only)
+    
+    Returns:
+        str: Calculated subnet information in JSON format
+    """
+    try:
+        number_int = int(number.strip())
+        result = calculate_subnets(
+            network.strip(), 
+            number_int, 
+            division_type.strip(), 
+            hosts_per_subnet.strip()
+        )
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)}, indent=2)
+
+
+# MCP API function for diagram generation  
+def generate_diagram_api(ip_network: str, hosts_list: str) -> str:
+    """MCP API wrapper for diagram generation that returns JSON."""
+    return generate_diagram_mcp(ip_network, hosts_list)
+
+
+# Gradio UI wrapper for diagram generation
+def generate_diagram_ui(ip_network: str, hosts_list: str):
+    """Gradio UI wrapper for diagram generation that handles errors gracefully."""
+    try:
+        if not ip_network.strip() or not hosts_list.strip():
+            return None
+        result = generate_diagram(ip_network, hosts_list)
+        return result
+    except Exception as e:
+        # Return None if there's any error - Gradio will handle this gracefully
+        return None
+
+
+def create_interface():
+    """Create the Gradio interface."""
+    
+    # Create separate interfaces for MCP tools only
+    ip_interface = gr.Interface(
+        fn=ip_info,
+        api_name="ip_info",
+        inputs=[
+            gr.Textbox(label="IP Address", placeholder="192.168.1.10"),
+            gr.Textbox(label="Subnet Mask", placeholder="/24 or 255.255.255.0")
+        ],
+        outputs=gr.Textbox(label="Analysis Result"),
+        title="IP Info",
+        description="Analyze IPv4 addresses with subnet masks"
+    )
+    
+    subnet_interface = gr.Interface(
+        fn=subnet_calculator,
+        api_name="subnet_calculator",
+        inputs=[
+            gr.Textbox(label="Network", placeholder="192.168.1.0/24"),
+            gr.Textbox(label="Number", placeholder="4"),
+            gr.Dropdown(label="Division Type", choices=["max_subnets","max_hosts_per_subnet","vlsm"], value="max_subnets"),
+            gr.Textbox(label="Hosts per Subnet", placeholder="100,50,25,10")
+        ],
+        outputs=gr.Textbox(label="Calculation Result"),
+        title="Subnet Calculator",
+        description="Calculate subnets using different methods"
+    )
+    
+    diagram_interface = gr.Interface(
+        fn=generate_diagram_ui,
+        api_name="generate_diagram",
+        inputs=[
+            gr.Textbox(label="Network", placeholder="192.168.1.0/24"),
+            gr.Textbox(label="Hosts per Subnet", placeholder="50,20,10,5")
+        ],
+        outputs=gr.Image(label="Network Diagram", type="filepath"),
+        title="Network Diagram Generator",
+        description="Generate network diagrams with SVG output"
+    )
+    
+    # Combine all the MCP tool interfaces
+    combined_app = gr.TabbedInterface(
+        [ip_interface, subnet_interface, diagram_interface],
+        ["IP Info", "Subnet Calculator", "Network Diagram"],
+        title=f"{APP_NAME} - MCP Tools"
+    )
+    
+    return combined_app

requirements.txt

@@ -0,0 +1,2 @@
+gradio[mcp]>=4.44.0
+python-dotenv>=1.0.0