┌─────────────────────────────────────────────────────────────┐
│                    Docker Container                          │
│                                                              │
│  ┌────────────────────────────────────────────────────────┐ │
│  │       Validation & Installation Layer                  │ │
│  │  - Validates MCP servers on startup                    │ │
│  │  - Installs npm packages (npx servers)                 │ │
│  │  - Pre-caches Python packages (uvx servers)            │ │
│  │  - Verifies HTTP server reachability                   │ │
│  │  - Executes manual_install_command (custom installs)   │ │
│  └────────────────────────────────────────────────────────┘ │
│                           │                                  │
│                           ▼                                  │
│  ┌────────────────────────────────────────────────────────┐ │
│  │           FastMCP HTTP Server (Port 8000)              │ │
│  │                                                        │ │
│  │  Tools:                                                │ │
│  │  - list_tools()         : Lists available MCP clients  │ │
│  │  - multi_tool_executer(): Executes dynamic Python code│ │
│  └────────────────────────────────────────────────────────┘ │
│                           │                                  │
│                           ▼                                  │
│  ┌────────────────────────────────────────────────────────┐ │
│  │         MCP Clients Manager (9 clients)                │ │
│  │  - context7_mcp_client                                 │ │
│  │  - fetch_mcp_client                                    │ │
│  │  - playwright_mcp_client (32 tools)                    │ │
│  │  - chrome-devtools_mcp_client (26 tools)               │ │
│  │  - sqlite_mcp_client (6 tools)                         │ │
│  │  - git_mcp_client                                      │ │
│  │  - ... (9 total)                                       │ │
│  └────────────────────────────────────────────────────────┘ │
│                           │                                  │
│                           ▼                                  │
│  ┌────────────────────────────────────────────────────────┐ │
│  │      Runtime Script Execution Engine                   │ │
│  │  - Generate unique UID per execution                   │ │
│  │  - Isolated sandbox environment                        │ │
│  │  - Timeout enforcement (60s default)                   │ │
│  │  - Automatic cleanup                                   │ │
│  │  - Async/await support for MCP clients                 │ │
│  │  - extract_content helper for result parsing           │ │
│  └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                           │
                           ▼
              External MCP Servers (HTTP/STDIO)

git clone <repository-url>
cd wasm_mcp

# Copy example environment file
cp .env.example .env

# Verify configuration
make test-validation

make build
make run

# Check health
make health

# Validate MCP tools
make validate

{
  "python_code": "async def execute_tools(initial_input, **kwargs):
    """
    List all VG-UI components using the vg_ui_lib_mcp_server.
    
    This will:
    1. Get startup instructions
    2. List all available components
    3. Get component categories
    """
    vg_ui_client = kwargs.get("vg_ui_lib_mcp_server_mcp_client")
    extract_content = kwargs.get("extract_content")
    
    if not vg_ui_client:
        return {
            "result": None,
            "result_explanation": "VG-UI MCP client is not available in the configuration."
        }
    
    try:
        results = {}
        
        # Step 1: Get startup instructions
        async with vg_ui_client:
            startup_result = await vg_ui_client.call_tool(
                "StartupInstructions",
                {}
            )
        
        # Extract startup instructions
        if hasattr(startup_result, 'content'):
            content = startup_result.content
            if isinstance(content, list) and len(content) > 0:
                startup_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                startup_text = str(content)
        else:
            startup_text = str(startup_result)
        
        results['startup_instructions'] = startup_text
        
        # Step 2: List all components
        async with vg_ui_client:
            components_result = await vg_ui_client.call_tool(
                "list_components",
                {}
            )
        
        # Extract components list
        if hasattr(components_result, 'content'):
            content = components_result.content
            if isinstance(content, list) and len(content) > 0:
                components_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                components_text = str(content)
        else:
            components_text = str(components_result)
        
        results['components'] = components_text
        
        # Step 3: List categories
        async with vg_ui_client:
            categories_result = await vg_ui_client.call_tool(
                "list_categories",
                {}
            )
        
        # Extract categories
        if hasattr(categories_result, 'content'):
            content = categories_result.content
            if isinstance(content, list) and len(content) > 0:
                categories_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                categories_text = str(content)
        else:
            categories_text = str(categories_result)
        
        results['categories'] = categories_text
        
        # Step 4: List CSS categories
        async with vg_ui_client:
            css_categories_result = await vg_ui_client.call_tool(
                "list_css_categories",
                {}
            )
        
        # Extract CSS categories
        if hasattr(css_categories_result, 'content'):
            content = css_categories_result.content
            if isinstance(content, list) and len(content) > 0:
                css_categories_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                css_categories_text = str(content)
        else:
            css_categories_text = str(css_categories_result)
        
        results['css_categories'] = css_categories_text
        
        # Step 5: List schemas
        async with vg_ui_client:
            schemas_result = await vg_ui_client.call_tool(
                "list_schemas",
                {}
            )
        
        # Extract schemas
        if hasattr(schemas_result, 'content'):
            content = schemas_result.content
            if isinstance(content, list) and len(content) > 0:
                schemas_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                schemas_text = str(content)
        else:
            schemas_text = str(schemas_result)
        
        results['schemas'] = schemas_text
        
        return {
            "result": results,
            "result_explanation": "Successfully retrieved VG-UI library documentation including startup instructions, component list, categories, CSS categories, and schemas."
        }
        
    except Exception as e:
        import traceback
        error_details = traceback.format_exc()
        return {
            "result": None,
            "result_explanation": f"Error while fetching VG-UI documentation: {str(e)}\
\
Traceback:\
{error_details}"
        }
",
  "input": {}
}

{
"success": true,
"result": {
"startup_instructions": "{"role":"assistant","content":{"type":"text","text":"\nThis MCP server provides access to VG UI Library web components documentation from the Storybook component registry.\nYou can use the tools to fetch, categorize, and retrieve information about VG web components, their schemas, CSS styles, and examples.\n\n# VG UI Library Web Components Documentation Server\n\n## Overview\nThis server provides access to comprehensive VG UI Library web component documentation including:\n- Component definitions with props, events, and slots\n- TypeScript type schemas and definitions\n- CSS variables and styling information (with categorization support)\n- Component examples and usage patterns with framework-specific filtering\n- Category-based component organization\n\n## Framework Filtering\nWhen fetching component examples, you can use the `--use-framework` command-line argument to filter sources for a specific framework:\n- Supported frameworks: `html`, `react`, `react19`, `vue`, `angular`, `lit`\n- Command-line usage: `--use-framework vue` will return only Vue.js code samples\n- Example: `python main.py --use-framework vue` or `fastmcp run main.py --use-framework react`\n- If no argument is provided or framework not found, all framework sources are returned\n\n## Instructions\n- List all VG UI Library components initially before starting implementation to understand available options\n- For any slot in web components, if documentation shows a `default` value, it can be used directly in the template\n- Use VG UI Library web components extensively and minimize custom HTML elements\n- Minimize custom CSS/styling and custom classes; prefer using VG component CSS properties and variables\n- In CSS: avoid absolute pixels, avoid custom colors (use VG CSS variables instead), prefer flexbox over grid\n- All VG UI Library components are prefixed with `vg-` (e.g., `vg-button`, `vg-card`, `vg-flex`)\n\n## Usage Guidelines\n1. Start by listing available components to understand what's available\n2. Use schema tools to understand TypeScript types and interfaces\n3. Get detailed component documentation for specific components\n4. Access CSS definitions for styling information\n5. Browse examples to see component usage patterns\n\n## Recommended Tool Usage Flow\n\n### For Finding and Using Components:\n1. **list_components** - Get overview of all available components (recommended first step)\n2. **search_components** - Search for components by name or category\n3. **get_component_by_tag** - Get specific component documentation with props, events, slots\n4. **get_component_example** - Get usage examples for specific component and example ID\n5. **list_categories** - Browse components by category\n\n### For TypeScript Types and Schemas:\n1. **list_schemas** - See available TypeScript types\n2. **get_schema_definition** - Get specific type definitions for interfaces, enums, and type aliases\n\n### For CSS Styles and Variables:\n1. **categorize_css** - Categorize CSS styles using LLM (run once per session, avoid unless necessary)\n2. **list_css_categories** - List all CSS categories\n3. **get_css_for_category** - Fetch CSS variables and styles for a specific category\n\n## Indexing and Categorizing\n- **categorize_css**: Avoid using this tool unless you want to re-categorize the CSS styles, as it will take time to process and categorize using LLM sampling.\n- Only call the categorization tool once per server session or if the quality of categorization is not good.\n- If CSS categories are not available, run `categorize_css` first, then use `list_css_categories` and `get_css_for_category`.\n\n## Best Practices\n- Always start with `list_components` or `search_components` to discover available components\n- Use `get_component_by_tag` to understand component APIs (props, events, slots) before implementation\n- Reference `get_component_example` for real usage patterns and framework-specific code samples\n- Use VG CSS variables for consistent theming and styling instead of hardcoded values\n- Leverage TypeScript schemas for type-safe component integration\n","annotations":null,"_meta":null}}",
"components": "["vg-input","vg-button","vg-dropdown","vg-theme-provider","vg-card"]",
"categories": "[{"category":"Input","components_count":1,"components":["vg-input"]},{"category":"Button","components_count":1,"components":["vg-button"]},{"category":"Dropdown","components_count":1,"components":["vg-dropdown"]},{"category":"ThemeProvider","components_count":1,"components":["vg-theme-provider"]},{"category":"Card","components_count":1,"components":["vg-card"]}]",
"css_categories": "No CSS categories found. Please run `categorize_css` to categorize the CSS styles.",
"schemas": "["ButtonVariant","ButtonSize","ButtonNativeType","ButtonClickDetail","CardVariant","CardActionDetail","DropdownOption","DropdownChangeDetail","InputType","InputChangeDetail","ThemeMode","ThemeChangeDetail"]"
},
"result_explanation": "Successfully retrieved VG-UI library documentation including startup instructions, component list, categories, CSS categories, and schemas."
}

{
    "success": true,
    "client_count": 9,
    "tools": {
        "context7": [
            "resolve-library-id(libraryName: string) -> dict",
            "get-library-docs(context7CompatibleLibraryID: string, topic: string, tokens: number) -> dict"
        ],
        "pulsemcp": [],
        "mcp_compass": [],
        "git": [],
        "fetch": [
            "fetch(url: string, max_length: integer, start_index: integer, raw: boolean) -> dict"
        ],
        "playwright": [
            "start_codegen_session(options: object) -> dict",
            "end_codegen_session(sessionId: string) -> dict",
            "get_codegen_session(sessionId: string) -> dict",
            "clear_codegen_session(sessionId: string) -> dict",
            "playwright_navigate(url: string, browserType: string, width: number, height: number, timeout: number, waitUntil: string, headless: boolean) -> dict",
            "playwright_screenshot(name: string, selector: string, width: number, height: number, storeBase64: boolean, fullPage: boolean, savePng: boolean, downloadsDir: string) -> dict",
            "playwright_click(selector: string) -> dict",
            "playwright_iframe_click(iframeSelector: string, selector: string) -> dict",
            "playwright_iframe_fill(iframeSelector: string, selector: string, value: string) -> dict",
            "playwright_fill(selector: string, value: string) -> dict",
            "playwright_select(selector: string, value: string) -> dict",
            "playwright_hover(selector: string) -> dict",
            "playwright_upload_file(selector: string, filePath: string) -> dict",
            "playwright_evaluate(script: string) -> dict",
            "playwright_console_logs(type: string, search: string, limit: number, clear: boolean) -> dict",
            "playwright_close() -> dict",
            "playwright_get(url: string) -> dict",
            "playwright_post(url: string, value: string, token: string, headers: object) -> dict",
            "playwright_put(url: string, value: string) -> dict",
            "playwright_patch(url: string, value: string) -> dict",
            "playwright_delete(url: string) -> dict",
            "playwright_expect_response(id: string, url: string) -> dict",
            "playwright_assert_response(id: string, value: string) -> dict",
            "playwright_custom_user_agent(userAgent: string) -> dict",
            "playwright_get_visible_text() -> dict",
            "playwright_get_visible_html(selector: string, removeScripts: boolean, removeComments: boolean, removeStyles: boolean, removeMeta: boolean, cleanHtml: boolean, minify: boolean, maxLength: number) -> dict",
            "playwright_go_back() -> dict",
            "playwright_go_forward() -> dict",
            "playwright_drag(sourceSelector: string, targetSelector: string) -> dict",
            "playwright_press_key(key: string, selector: string) -> dict",
            "playwright_save_as_pdf(outputPath: string, filename: string, format: string, printBackground: boolean, margin: object) -> dict",
            "playwright_click_and_switch_tab(selector: string) -> dict"
        ],
        "sqlite": [
            "read_query(query: string) -> dict",
            "write_query(query: string) -> dict",
            "create_table(query: string) -> dict",
            "list_tables() -> dict",
            "describe_table(table_name: string) -> dict",
            "append_insight(insight: string) -> dict"
        ],
        "chrome-devtools": [
            "list_console_messages() -> dict",
            "emulate_cpu(throttlingRate: number) -> dict",
            "emulate_network(throttlingOption: string) -> dict",
            "click(uid: string, dblClick: boolean) -> dict",
            "drag(from_uid: string, to_uid: string) -> dict",
            "fill(uid: string, value: string) -> dict",
            "fill_form(elements: array) -> dict",
            "hover(uid: string) -> dict",
            "upload_file(uid: string, filePath: string) -> dict",
            "get_network_request(url: string) -> dict",
            "list_network_requests(pageSize: integer, pageIdx: integer, resourceTypes: array) -> dict",
            "close_page(pageIdx: number) -> dict",
            "handle_dialog(action: string, promptText: string) -> dict",
            "list_pages() -> dict",
            "navigate_page(url: string, timeout: integer) -> dict",
            "navigate_page_history(navigate: string, timeout: integer) -> dict",
            "new_page(url: string, timeout: integer) -> dict",
            "resize_page(width: number, height: number) -> dict",
            "select_page(pageIdx: number) -> dict",
            "performance_analyze_insight(insightName: string) -> dict",
            "performance_start_trace(reload: boolean, autoStop: boolean) -> dict",
            "performance_stop_trace() -> dict",
            "take_screenshot(format: string, quality: number, uid: string, fullPage: boolean, filePath: string) -> dict",
            "evaluate_script(function: string, args: array) -> dict",
            "take_snapshot() -> dict",
            "wait_for(text: string, timeout: integer) -> dict"
        ],
        "vg_ui_lib_mcp_server": [
            "ClearCache() -> dict",
            "StartupInstructions() -> dict",
            "InitialProjectSetup() -> dict",
            "list_components() -> dict",
            "get_component_by_tag(component_tag: string) -> dict",
            "search_components(search_term: string) -> dict",
            "list_schemas() -> dict",
            "get_schema_definition(schema_name: string) -> dict",
            "list_categories() -> dict",
            "get_component_example(component_tag: string, example_id: string) -> dict",
            "categorize_css() -> dict",
            "list_css_categories() -> dict",
            "get_css_for_category(category_name: string) -> dict"
        ]
    }
}

==========================================
Multi-Tool MCP Server - Starting
==========================================
[2025-01-11 10:30:15] Configuration loaded with 27 MCP servers
[2025-01-11 10:30:15] Validating and installing MCP tools...

==========================================
Starting MCP Tools Validation
==========================================

[1/27] Validating: context7
  ✅ Status: ok - HTTP 200

[2/27] Validating: filesystem
  ✅ Status: ok - Installed successfully

[3/27] Validating: git
  ✅ Status: ok - Pre-cached successfully

[4/27] Validating: github
  ⏭️  Status: skipped - Server disabled

==========================================
Validation Summary
==========================================
Total servers: 27
✅ Available: 13
⏭️  Skipped: 12
❌ Failed: 2
==========================================

# Test validation system
make test-validation

# Validate in running container
make validate

# Validate with strict mode (fails on errors)
make validate-strict

# Validate locally (no Docker)
make validate-local

make run
# Warns on failures, continues startup

docker run -e STRICT_VALIDATION=true ...
# Exits on any validation failure

python3 scripts/validate_mcp_tools.py --no-install
# Only validates, doesn't install

{
  "context7": {
    "type": "http",
    "url": "https://mcp.context7.com/mcp",
    "description": "Library documentation"
  }
}

{
  "puppeteer": {
    "type": "stdio",
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-puppeteer"],
    "description": "Browser automation"
  }
}

{
  "git": {
    "type": "stdio",
    "command": "uvx",
    "args": ["mcp-server-git", "--repository", "."],
    "description": "Git operations"
  }
}

{
  "custom_server": {
    "type": "stdio",
    "command": "uvx",
    "args": ["custom-server", "--option", "value"],
    "manual_install_command": "uv tool install https://example.com/package.whl",
    "description": "Custom package from URL"
  }
}

{
  "chrome-devtools": {
    "type": "stdio",
    "command": "npx",
    "args": ["chrome-devtools-mcp@latest", "--headless=true", "--isolated"],
    "description": "Chrome DevTools with isolated instances"
  }
}

{
  "github": {
    "type": "stdio",
    "enabled": false,
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
    }
  }
}

{
  "mcpServers": {
    "multi_mcp_tool_executer": {
      "type": "http",
      "url": "http://localhost:8000/mcp",
      "transport": "http"
    }
  }
}

{
  "success": true,
  "client_count": 9,
  "tools": {
    "context7_mcp_client": [
      "resolve_library_id(library_name: str) -> dict",
      "get_library_docs(library_id: str, topic: str, tokens: int) -> str"
    ],
    "playwright_mcp_client": [
      "playwright_navigate(url: str, browserType: str, waitUntil: str) -> dict",
      "playwright_screenshot(name: str, savePng: bool) -> dict",
      "... (32 tools total)"
    ],
    "chrome_devtools_mcp_client": [
      "chrome_navigate(url: str) -> dict",
      "chrome_click(selector: str) -> dict",
      "... (26 tools total)"
    ]
  }
}

async def execute_tools(initial_input: Any, **kwargs: Dict[str, Any]) -> Dict[str, Any]:
    """
    Args:
        initial_input: The input data provided
        **kwargs: MCP clients and helper functions
            - {name}_mcp_client: MCP client objects
            - extract_content: Helper to parse CallToolResult objects

    Returns:
        Dict with 'result' and 'result_explanation' keys
    """
    pass

async def execute_tools(initial_input, **kwargs):
    fetch_client = kwargs.get("fetch_mcp_client")
    extract_content = kwargs.get("extract_content")

    # MUST use 'async with' before calling any client methods
    async with fetch_client:
        result = await fetch_client.call_tool(
            "fetch",
            {"url": "https://api.ipify.org?format=json"}
        )

    # Use extract_content to parse the CallToolResult
    parsed_data = extract_content(result)

    return {
        "result": parsed_data,
        "result_explanation": f"Fetched IP: {parsed_data.get('ip', 'N/A')}"
    }

async def execute_tools(initial_input, **kwargs):
    fetch_client = kwargs.get("fetch_mcp_client")

    # Missing 'async with' - THIS WILL FAIL
    result = await fetch_client.call_tool("fetch", {"url": "..."})

    return {"result": result, "result_explanation": "..."}

async def execute_tools(initial_input, **kwargs):
    context7_client = kwargs.get("context7_mcp_client")
    fetch_client = kwargs.get("fetch_mcp_client")
    extract_content = kwargs.get("extract_content")

    # Use each client within its own async with block
    async with context7_client:
        docs = await context7_client.call_tool(
            "get-library-docs",
            {"context7CompatibleLibraryID": "/python/requests"}
        )

    async with fetch_client:
        data = await fetch_client.call_tool(
            "fetch",
            {"url": "https://api.example.com"}
        )

    return {
        "result": {
            "docs": extract_content(docs),
            "data": extract_content(data)
        },
        "result_explanation": "Retrieved docs and fetched data"
    }

python_code = """
async def execute_tools(initial_input: Any, **kwargs: Dict[str, Any]) -> Dict[str, Any]:
    context7 = kwargs.get("context7_mcp_client")
    extract_content = kwargs.get("extract_content")

    library_name = initial_input["library"]

    async with context7:
        result = await context7.call_tool(
            "resolve-library-id",
            {"libraryName": library_name}
        )

    library_data = extract_content(result)

    return {
        "result": library_data,
        "result_explanation": f"Found documentation for {library_name}"
    }
"""

input_data = {"library": "fastmcp"}

python_code = """
async def execute_tools(initial_input: dict, **kwargs) -> dict:
    playwright_client = kwargs.get("playwright_mcp_client")
    extract_content = kwargs.get("extract_content")

    # 1. Launch browser and navigate
    async with playwright_client:
        await playwright_client.call_tool("playwright_navigate", {
            "url": "https://whatismyipaddress.com/",
            "browserType": "chromium",
            "waitUntil": "load",
            "headless": True
        })

    # 2. Extract page content
    async with playwright_client:
        text_result = await playwright_client.call_tool(
            "playwright_get_visible_text", {}
        )

    text = extract_content(text_result)

    # 3. Capture screenshot
    async with playwright_client:
        await playwright_client.call_tool("playwright_screenshot", {
            "name": "ip_page",
            "savePng": True
        })

    # 4. Parse IP from page text
    import re
    ip_match = re.search(r'IPv4:.*?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})', text)
    ip_address = ip_match.group(1) if ip_match else "Not found"

    # 5. Cleanup
    async with playwright_client:
        await playwright_client.call_tool("playwright_close", {})

    return {
        "result": {"ip_address": ip_address, "page_text": text[:200]},
        "result_explanation": f"Successfully extracted IP: {ip_address}"
    }
"""

input_data = {}

python_code = """
async def execute_tools(initial_input: Any, **kwargs: Dict[str, Any]) -> Dict[str, Any]:
    filesystem = kwargs.get("filesystem_mcp_client")
    git = kwargs.get("git_mcp_client")
    extract_content = kwargs.get("extract_content")

    filepath = initial_input["file"]

    # Read file
    async with filesystem:
        content_result = await filesystem.call_tool("read_file", {"path": filepath})

    content = extract_content(content_result)

    # Check git status
    async with git:
        status_result = await git.call_tool("git_status", {"repository": "."})

    git_status = extract_content(status_result)

    return {
        "result": {
            "file": filepath,
            "content_length": len(content),
            "git_tracked": "tracked" in str(git_status).lower()
        },
        "result_explanation": f"Processed {filepath} with git status check"
    }
"""

input_data = {"file": "/path/to/file.txt"}

python_code = """
async def execute_tools(initial_input: Any, **kwargs: Dict[str, Any]) -> Dict[str, Any]:
    items = initial_input["items"]

    processed_items = []
    for item in items:
        processed_items.append({
            "original": item,
            "processed": item.upper(),
            "length": len(item)
        })

    return {
        "result": {
            "total_processed": len(processed_items),
            "items": processed_items
        },
        "result_explanation": f"Successfully processed {len(items)} items"
    }
"""

input_data = {"items": ["hello", "world", "fastmcp"]}

python_code = """
async def execute_tools(initial_input, **kwargs):
    '''
    List all VG-UI components using the vg_ui_lib_mcp_server.

    This will:
    1. Get startup instructions
    2. List all available components
    3. Get component categories
    4. List CSS categories
    5. List TypeScript schemas
    '''
    vg_ui_client = kwargs.get("vg_ui_lib_mcp_server_mcp_client")
    extract_content = kwargs.get("extract_content")

    if not vg_ui_client:
        return {
            "result": None,
            "result_explanation": "VG-UI MCP client is not available in the configuration."
        }

    try:
        results = {}

        # Step 1: Get startup instructions
        async with vg_ui_client:
            startup_result = await vg_ui_client.call_tool(
                "StartupInstructions",
                {}
            )

        # Extract startup instructions
        if hasattr(startup_result, 'content'):
            content = startup_result.content
            if isinstance(content, list) and len(content) > 0:
                startup_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                startup_text = str(content)
        else:
            startup_text = str(startup_result)

        results['startup_instructions'] = startup_text

        # Step 2: List all components
        async with vg_ui_client:
            components_result = await vg_ui_client.call_tool(
                "list_components",
                {}
            )

        # Extract components list
        if hasattr(components_result, 'content'):
            content = components_result.content
            if isinstance(content, list) and len(content) > 0:
                components_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                components_text = str(content)
        else:
            components_text = str(components_result)

        results['components'] = components_text

        # Step 3: List categories
        async with vg_ui_client:
            categories_result = await vg_ui_client.call_tool(
                "list_categories",
                {}
            )

        # Extract categories
        if hasattr(categories_result, 'content'):
            content = categories_result.content
            if isinstance(content, list) and len(content) > 0:
                categories_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                categories_text = str(content)
        else:
            categories_text = str(categories_result)

        results['categories'] = categories_text

        # Step 4: List CSS categories
        async with vg_ui_client:
            css_categories_result = await vg_ui_client.call_tool(
                "list_css_categories",
                {}
            )

        # Extract CSS categories
        if hasattr(css_categories_result, 'content'):
            content = css_categories_result.content
            if isinstance(content, list) and len(content) > 0:
                css_categories_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                css_categories_text = str(content)
        else:
            css_categories_text = str(css_categories_result)

        results['css_categories'] = css_categories_text

        # Step 5: List schemas
        async with vg_ui_client:
            schemas_result = await vg_ui_client.call_tool(
                "list_schemas",
                {}
            )

        # Extract schemas
        if hasattr(schemas_result, 'content'):
            content = schemas_result.content
            if isinstance(content, list) and len(content) > 0:
                schemas_text = content[0].text if hasattr(content[0], 'text') else str(content[0])
            else:
                schemas_text = str(content)
        else:
            schemas_text = str(schemas_result)

        results['schemas'] = schemas_text

        return {
            "result": results,
            "result_explanation": "Successfully retrieved VG-UI library documentation including startup instructions, component list, categories, CSS categories, and schemas."
        }

    except Exception as e:
        import traceback
        error_details = traceback.format_exc()
        return {
            "result": None,
            "result_explanation": f"Error while fetching VG-UI documentation: {str(e)}\\n\\nTraceback:\\n{error_details}"
        }
"""

input_data = {}

{
  "success": true,
  "result": {
    "startup_instructions": "{\"role\":\"assistant\",\"content\":{...}}",
    "components": "[\"vg-input\",\"vg-button\",\"vg-dropdown\",\"vg-theme-provider\",\"vg-card\"]",
    "categories": "[{\"category\":\"Input\",\"components_count\":1,...}]",
    "css_categories": "No CSS categories found. Please run `categorize_css` to categorize the CSS styles.",
    "schemas": "[\"ButtonVariant\",\"ButtonSize\",\"ButtonNativeType\",...]"
  },
  "result_explanation": "Successfully retrieved VG-UI library documentation including startup instructions, component list, categories, CSS categories, and schemas."
}

# In .env file
FASTMCP_DEV_MODE=true

# Or via Docker command
docker run -e FASTMCP_DEV_MODE=true ...

pip install 'fastmcp[dev]'

# Update .env
FASTMCP_DEV_MODE=true

# Rebuild and run
make rebuild

# Or run directly
docker run -d \
  -e FASTMCP_DEV_MODE=true \
  -p 8000:8000 \
  --env-file .env \
  multi-mcp-tool-executer:latest

# Set environment variable
export FASTMCP_DEV_MODE=true

# Run server
python -m src.server

# Or use FastMCP CLI directly
fastmcp dev src/server.py

# Install dependencies
make dev-install

# Run locally (without Docker)
make dev-run

# Run in dev mode with Inspector
export FASTMCP_DEV_MODE=true
make dev-run

# Format code
make dev-format

# Run linters
make dev-lint

# Test validation system
make test-validation

# In container
make test

# Locally
make test-local

wasm_mcp/
├── Dockerfile                  # Multi-stage Docker build
├── docker-compose.yml          # Docker Compose configuration
├── Makefile                    # Build automation
├── requirements.txt            # Python dependencies
├── .env                        # Environment configuration (27 MCP servers)
├── README.md                   # Comprehensive documentation (this file)
├── QUICKSTART.md               # Quick start guide
├── CLAUDE.md                   # Project instructions
│
├── src/
│   ├── __init__.py
│   ├── server.py               # Main FastMCP server
│   ├── client_manager.py       # MCP clients manager
│   ├── executor.py             # Runtime code executor
│   ├── config.py               # Configuration management
│   └── utils.py                # Utility functions
│
└── scripts/
    ├── validate_mcp_tools.py   # MCP tools validation script
    ├── install_mcp_packages.py # Build-time package installer
    ├── docker_entrypoint.sh    # Container startup script
    └── test_validation.sh      # Validation system tests

# Check server health
curl http://localhost:8000/health
make health

{
  "status": "healthy",
  "server": "Multi-Tool MCP Executer",
  "clients_configured": 9,
  "clients_initialized": 9
}

# Follow logs
make logs

# Last 100 lines
make logs-tail

# Docker Compose logs
make compose-logs

# View validation logs
make logs | grep "Validation"

# Container stats
make stats

# Inspect container
make inspect

# Check running processes
make ps

{
  "status": "healthy",
  "server": "Multi-Tool MCP Executer",
  "clients_configured": 9,
  "clients_initialized": 9
}

1. Container Startup
   ├── docker_entrypoint.sh executes
   ├── Dynamic browser version detection and symlinking
   └── Calls validate_mcp_tools.py
       ├── Parses MCP_SERVERS_CONFIGS
       ├── HTTP Servers: Tests reachability
       ├── STDIO Servers: Installs packages
       ├── Manual Install: Executes custom commands
       └── Reports validation results

2. FastMCP Server Initialization
   ├── Loads configuration from environment
   ├── Initializes MCP client connections (async with support)
   └── Exposes HTTP endpoint on port 8000

3. Client Request Handling
   ├── Receives tool call via HTTP
   ├── Routes to list_tools or multi_tool_executer
   └── Returns structured response

4. Code Execution (multi_tool_executer)
   ├── Generates unique UID
   ├── Creates isolated directory: /tmp/scripts/{UID}/
   ├── Writes Python code to script.py
   ├── Dynamic import and execution (async support)
   ├── Provides extract_content helper for result parsing
   ├── Captures result and logs
   ├── Cleanup temporary files
   └── Returns result + explanation

class MCPToolValidator:
    def __init__(self, config_str: str)
        # Parses MCP_SERVERS_CONFIGS JSON

    def check_http_server(self, url: str) -> Tuple[bool, str]
        # Tests HTTP server reachability with timeout

    def check_command_available(self, command: str) -> bool
        # Verifies command exists in PATH

    def install_npx_package(self, package: str) -> Tuple[bool, str]
        # Runs: npm install -g {package}

    def install_uvx_package(self, package: str) -> Tuple[bool, str]
        # Runs: uv tool install {package}

    def validate_and_install_server(self, name: str, config: Dict) -> Dict
        # Orchestrates validation and installation

    def run_validation(self, strict: bool, no_install: bool) -> Dict
        # Main validation loop with reporting

def run_manual_install(command: str, server_name: str) -> bool:
    """Execute manual installation command"""
    result = subprocess.run(
        command,
        shell=True,
        capture_output=True,
        text=True,
        timeout=600  # 10 minutes for manual installations
    )

@mcp.tool(name="list_tools")
def list_tools() -> dict:
    # Queries all MCP clients
    # Returns unified tool list with signatures

@mcp.tool(name="multi_tool_executer")
def multi_tool_executer(python_code: str, input: Any) -> dict:
    # Generates UID
    # Writes code to isolated directory
    # Dynamically imports and executes (async support)
    # Provides extract_content helper
    # Returns structured result

1. Generate UUID4 for execution instance
2. Create directory: /tmp/scripts/{uuid}/
3. Write user code to {uuid}/script.py
4. Add helper functions (extract_content)
5. Import: importlib.import_module(f"scripts.{uuid}.script")
6. Execute: await module.execute_tools(input, **mcp_clients) if async
7. Capture result dictionary
8. Clean up temporary directory
9. Return result with explanation

# 1. Launch browser and navigate
async with playwright_client:
    await playwright_client.call_tool("playwright_navigate", {
        "url": "https://example.com",
        "browserType": "chromium",
        "waitUntil": "load",
        "headless": True
    })

# 2. Extract page content
async with playwright_client:
    text_result = await playwright_client.call_tool(
        "playwright_get_visible_text", {}
    )

# 3. Capture screenshot
async with playwright_client:
    await playwright_client.call_tool("playwright_screenshot", {
        "name": "page_screenshot",
        "savePng": True
    })

# 4. Cleanup
async with playwright_client:
    await playwright_client.call_tool("playwright_close", {})

{
  "chrome-devtools": {
    "args": ["chrome-devtools-mcp@latest", "--headless=true", "--isolated"]
  }
}

1. manual_install_command (if present)
2. npm packages (npx command)
3. uv packages (uvx command)

{
  "custom_server": {
    "type": "stdio",
    "command": "uvx",
    "args": ["custom-server", "--option", "value"],
    "manual_install_command": "uv tool install https://example.com/package.whl",
    "description": "Custom package from URL"
  }
}

{
  "git_mcp": {
    "type": "stdio",
    "command": "uvx",
    "args": ["git-mcp-server"],
    "manual_install_command": "uv tool install git+https://github.com/user/mcp.git",
    "description": "Custom MCP from Git"
  }
}

{
  "special_mcp": {
    "type": "stdio",
    "command": "python",
    "args": ["-m", "special_mcp"],
    "manual_install_command": "pip install special-mcp-package==1.2.3",
    "description": "MCP requiring specific pip install"
  }
}

{
  "build_mcp": {
    "type": "stdio",
    "command": "node",
    "args": ["dist/server.js"],
    "manual_install_command": "cd /tmp && git clone https://github.com/user/mcp.git && cd mcp && npm install && npm run build",
    "description": "MCP requiring build from source"
  }
}