update to auto deploy

app.py

@@ -1,401 +1,471 @@
-"""
-MCP Generator - Gradio Frontend
-Turn any API into an MCP server in seconds!
-"""
-
-import asyncio
-import gradio as gr
-from pathlib import Path
-import zipfile
-import io
-import os
-
-from src.agents.factory import AgentFactory
-from src.mcp_host import mcp_host
-from src.mcp_registry import mcp_registry
-from src.config import LLM_PROVIDER, ANTHROPIC_API_KEY, OPENAI_API_KEY, HOSTED_MCPS_DIR
-
-
-# Initialize agent factory
-try:
-    agent_factory = AgentFactory()
-    print(f"✅ Using {LLM_PROVIDER.upper()} for code generation")
-except ValueError as e:
-    print(f"❌ Error: {e}")
-    print(f"Please set {'ANTHROPIC_API_KEY' if LLM_PROVIDER == 'anthropic' else 'OPENAI_API_KEY'} in .env file")
-    agent_factory = None
-
-
-async def generate_and_host_mcp(api_url: str, api_key: str = None, force_regenerate: bool = False, progress=gr.Progress()):
-    """Generate and host an MCP server
-
-    Args:
-        api_url: The API URL to analyze
-        api_key: Optional API key for the target API
-        force_regenerate: If True, regenerate even if exists
-        progress: Gradio progress tracker
-
-    Returns:
-        Tuple of (status_text, code, download_file, readme, connection_config)
-    """
-    if not agent_factory:
-        api_key_name = "ANTHROPIC_API_KEY" if LLM_PROVIDER == "anthropic" else "OPENAI_API_KEY"
-        return (
-            f"❌ Error: {api_key_name} not configured. Please set it in your .env file.",
-            "",
-            None,
-            "",
-            ""
-        )
-
-    try:
-        # Check if MCP already exists for this URL
-        existing_mcp = mcp_registry.find_by_url(api_url)
-
-        if existing_mcp and not force_regenerate:
-            progress(0.5, desc="Found existing MCP, reusing...")
-
-            # Reuse existing MCP
-            mcp_id = existing_mcp['mcp_id']
-            mcp_path = HOSTED_MCPS_DIR / mcp_id
-
-            # Update last used timestamp
-            mcp_registry.update_last_used(api_url)
-
-            # Load existing files
-            server_code = (mcp_path / "server.py").read_text()
-            readme = (mcp_path / "README.md").read_text()
-
-            status_text = f"""♻️ **Reusing Existing MCP!**
-
-**MCP ID:** `{mcp_id}`
-**Originally Created:** {existing_mcp['created_at']}
-**Last Used:** {existing_mcp['last_used']}
-
-This MCP was already generated for this API URL. Using existing version to save time and API calls!
-
-💡 **Tip:** To regenerate from scratch, check "Force Regenerate" below.
-"""
-
-            # Create ZIP file
-            zip_buffer = io.BytesIO()
-            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
-                for file_path in mcp_path.rglob('*'):
-                    if file_path.is_file():
-                        arcname = file_path.relative_to(mcp_path.parent)
-                        zipf.write(file_path, arcname)
-
-            zip_buffer.seek(0)
-            temp_zip = f"/tmp/{mcp_id}.zip"
-            with open(temp_zip, 'wb') as f:
-                f.write(zip_buffer.read())
-
-            connection_config = f"""{{
-  "mcpServers": {{
-    "{mcp_id}": {{
-      "command": "python",
-      "args": ["server.py"]
-    }}
-  }}
-}}"""
-
-            return (
-                status_text,
-                server_code,
-                temp_zip,
-                readme,
-                connection_config
-            )
-
-        # Generate new MCP
-        if existing_mcp:
-            progress(0.1, desc="Regenerating MCP (forced)...")
-        else:
-            progress(0.1, desc="Analyzing API...")
-
-        # Generate the MCP
-        result = await agent_factory.generate_mcp(api_url, api_key)
-
-        if result["status"] == "error":
-            return (
-                f"❌ Error: {result['error']}",
-                "",
-                None,
-                "",
-                ""
-            )
-
-        progress(0.6, desc="Generating code...")
-
-        # Get the generated files
-        mcp_id = result["mcp_id"]
-        server_code = result["server_code"]
-        readme = result["readme_content"]
-
-        progress(0.8, desc="Starting MCP server...")
-
-        # Start the MCP server
-        start_result = await mcp_host.start_mcp(mcp_id)
-
-        if not start_result["success"]:
-            status_text = f"⚠️ MCP generated but failed to start: {start_result.get('error')}"
-        else:
-            status_text = f"""✅ **MCP Server Running!**
-
-**MCP ID:** `{mcp_id}`
-**Status:** {start_result['status']}
-**Connection:** stdio (local)
-
-Your MCP server is generated and ready to use!
-"""
-
-        progress(0.9, desc="Creating download package...")
-
-        # Create ZIP file for download
-        zip_buffer = io.BytesIO()
-        mcp_path = Path(result["download_path"])
-
-        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            for file_path in mcp_path.rglob('*'):
-                if file_path.is_file():
-                    arcname = file_path.relative_to(mcp_path.parent)
-                    zipf.write(file_path, arcname)
-
-        zip_buffer.seek(0)
-
-        # Save to temp file for Gradio
-        temp_zip = f"/tmp/{mcp_id}.zip"
-        with open(temp_zip, 'wb') as f:
-            f.write(zip_buffer.read())
-
-        # Create connection config
-        connection_config = f"""{{
-  "mcpServers": {{
-    "{mcp_id}": {{
-      "command": "python",
-      "args": ["server.py"]
-    }}
-  }}
-}}"""
-
-        progress(1.0, desc="Done!")
-
-        return (
-            status_text,
-            server_code,
-            temp_zip,
-            readme,
-            connection_config
-        )
-
-    except Exception as e:
-        return (
-            f"❌ Unexpected error: {str(e)}",
-            "",
-            None,
-            "",
-            ""
-        )
-
-
-# Build Gradio Interface
-with gr.Blocks(
-    title="MCP Generator"
-) as app:
-
-    gr.Markdown("""
-    # 🤖 MCP Generator
-    ## Turn Any API into an MCP Server in Seconds!
-
-    Simply enter an API URL and we'll generate a complete, working MCP server with:
-    - ✅ Automatically analyzed endpoints
-    - ✅ Generated MCP tools
-    - ✅ Complete documentation
-    - ✅ Ready to use immediately!
-
-    **Built for the MCP 1st Birthday Hackathon** 🎉
-    """)
-
-    with gr.Accordion("ℹ️ API URL Guidelines & Tips", open=False):
-        gr.Markdown("""
-        ### ✅ What Works Best:
-        - **Base API URLs** (e.g., `https://api.example.com`)
-        - **REST APIs** with clear endpoints
-        - **OpenAPI/Swagger** documented APIs
-        - **Public APIs** (no complex auth)
-
-        ### 🎯 Try These Free APIs:
-
-        **No Auth Required (Perfect for Testing!):**
-        - `https://jsonplaceholder.typicode.com` - Fake REST API (best for testing!)
-        - `https://api.github.com` - GitHub public API
-        - `https://dog.ceo/api` - Random dog images
-        - `https://catfact.ninja` - Random cat facts
-        - `https://api.coindesk.com/v1/bpi` - Bitcoin prices
-        - `https://api.ipify.org` - Get IP address
-
-        **With API Key (Free Tier):**
-        - `https://api.openweathermap.org/data/2.5` - Weather data
-        - `https://newsapi.org/v2` - News articles
-        - `https://api.stripe.com` - Payment processing (test mode)
-
-        ### 💡 Tips:
-        - **Start with jsonplaceholder.typicode.com** - always works!
-        - Paste the **base URL** (not a specific endpoint)
-        - If API needs a key, add it in the "API Key" field below
-        - Cached URLs generate instantly (try the same URL twice!)
-
-        ### ⚠️ May Not Work Well:
-        - GraphQL APIs (REST only for now)
-        - APIs requiring OAuth flows
-        - WebSocket-only APIs
-        - APIs with very complex authentication
-        """)
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown("### 📝 Input")
-
-            api_url = gr.Textbox(
-                label="API URL or Documentation URL",
-                placeholder="https://api.example.com",
-                info="Enter the base URL or documentation URL of the API"
-            )
-
-            api_key = gr.Textbox(
-                label="API Key (Optional)",
-                placeholder="sk-...",
-                type="password",
-                info="If the API requires authentication"
-            )
-
-            force_regenerate = gr.Checkbox(
-                label="Force Regenerate",
-                value=False,
-                info="Regenerate even if MCP already exists for this URL (saves API calls when unchecked)"
-            )
-
-            generate_btn = gr.Button(
-                "🚀 Generate & Host MCP Server",
-                variant="primary",
-                size="lg"
-            )
-
-            with gr.Accordion("🚀 Quick Start Examples", open=True):
-                gr.Markdown("""
-                **Click to copy and paste:**
-
-                ```
-                https://jsonplaceholder.typicode.com
-                ```
-                ⭐ **Recommended first try!** Always works, no API key needed.
-
-                ---
-
-                **More examples:**
-                - `https://api.github.com` - GitHub API (no auth)
-                - `https://dog.ceo/api` - Dog images (fun!)
-                - `https://catfact.ninja` - Cat facts (simple)
-
-                💡 **Tip:** MCPs are cached - try the same URL twice to see instant results!
-                """)
-
-    gr.Markdown("---")
-
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 📊 Results")
-
-            status_output = gr.Markdown(label="Status")
-
-            with gr.Tab("Generated Code"):
-                code_output = gr.Code(
-                    label="server.py",
-                    language="python",
-                    lines=20
-                )
-
-            with gr.Tab("README"):
-                readme_output = gr.Markdown()
-
-            with gr.Tab("Connection Config"):
-                connection_output = gr.Code(
-                    label="Claude Desktop Config",
-                    language="json"
-                )
-
-            download_output = gr.File(
-                label="📦 Download Complete Package (ZIP)"
-            )
-
-    # Wire up the button
-    generate_btn.click(
-        fn=generate_and_host_mcp,
-        inputs=[api_url, api_key, force_regenerate],
-        outputs=[
-            status_output,
-            code_output,
-            download_output,
-            readme_output,
-            connection_output
-        ]
-    )
-
-    with gr.Accordion("📋 Previously Generated MCPs", open=False):
-        def get_existing_mcps():
-            """Get list of existing MCPs for display"""
-            mcps = mcp_registry.list_all()
-            if not mcps:
-                return "No MCPs generated yet. Generate your first one above! 👆"
-
-            output = "| API Name | URL | Created | Last Used |\n"
-            output += "|----------|-----|---------|----------|\n"
-            for mcp in mcps[:10]:  # Show last 10
-                api_name = mcp['api_name']
-                api_url = mcp['api_url'][:40] + "..." if len(mcp['api_url']) > 40 else mcp['api_url']
-                created = mcp['created_at'].split('T')[0]
-                last_used = mcp['last_used'].split('T')[0]
-                output += f"| {api_name} | {api_url} | {created} | {last_used} |\n"
-
-            return output
-
-        existing_mcps_display = gr.Markdown(get_existing_mcps())
-        refresh_btn = gr.Button("🔄 Refresh List", size="sm")
-        refresh_btn.click(fn=get_existing_mcps, outputs=existing_mcps_display)
-
-    gr.Markdown("""
-    ---
-    ### 🎯 How to Use Your Generated MCP
-
-    1. **Download** the ZIP file above
-    2. **Extract** it to a folder
-    3. **Add** the connection config to your Claude Desktop settings
-    4. **Restart** Claude Desktop
-
-    Your MCP server is ready to use! 🎉
-
-    ### 🚀 About This Project
-
-    This is a meta-MCP: an MCP server that generates other MCP servers!
-
-    - Built with [Gradio](https://gradio.app)
-    - Powered by [LangGraph](https://github.com/langchain-ai/langgraph) agents
-    - Uses [Anthropic's Claude](https://anthropic.com) for code generation
-    - Integrates with [MCP Fetch Server](https://github.com/modelcontextprotocol/servers)
-
-    **For MCP 1st Birthday Hackathon - Track 2: MCP in Action** 🎂
-    """)
-
-
-if __name__ == "__main__":
-    # Check for API key
-    if not ANTHROPIC_API_KEY:
-        print("⚠️  WARNING: ANTHROPIC_API_KEY not set!")
-        print("Please create a .env file with your API key")
-        print("Example: echo 'ANTHROPIC_API_KEY=your_key_here' > .env")
-
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False
-    )
+"""
+MCP Generator - Gradio Frontend
+Turn any API into an MCP server in seconds!
+"""
+
+import asyncio
+import gradio as gr
+from pathlib import Path
+import zipfile
+import io
+import os
+
+from src.agents.factory import AgentFactory
+from src.mcp_host import mcp_host
+from src.mcp_http_host import mcp_http_host
+from src.mcp_registry import mcp_registry
+from src.config import LLM_PROVIDER, ANTHROPIC_API_KEY, OPENAI_API_KEY, HOSTED_MCPS_DIR
+
+
+# Initialize agent factory
+try:
+    agent_factory = AgentFactory()
+    print(f"✅ Using {LLM_PROVIDER.upper()} for code generation")
+except ValueError as e:
+    print(f"❌ Error: {e}")
+    print(f"Please set {'ANTHROPIC_API_KEY' if LLM_PROVIDER == 'anthropic' else 'OPENAI_API_KEY'} in .env file")
+    agent_factory = None
+
+
+async def generate_and_host_mcp(api_url: str, api_key: str = None, force_regenerate: bool = False, progress=gr.Progress()):
+    """Generate and host an MCP server
+
+    Args:
+        api_url: The API URL to analyze
+        api_key: Optional API key for the target API
+        force_regenerate: If True, regenerate even if exists
+        progress: Gradio progress tracker
+
+    Returns:
+        Tuple of (status_text, code, download_file, readme, connection_config)
+    """
+    if not agent_factory:
+        api_key_name = "ANTHROPIC_API_KEY" if LLM_PROVIDER == "anthropic" else "OPENAI_API_KEY"
+        return (
+            f"❌ Error: {api_key_name} not configured. Please set it in your .env file.",
+            "",
+            None,
+            "",
+            ""
+        )
+
+    try:
+        # Check if MCP already exists for this URL
+        existing_mcp = mcp_registry.find_by_url(api_url)
+
+        if existing_mcp and not force_regenerate:
+            progress(0.5, desc="Found existing MCP, reusing...")
+
+            # Reuse existing MCP
+            mcp_id = existing_mcp['mcp_id']
+            mcp_path = HOSTED_MCPS_DIR / mcp_id
+
+            # Update last used timestamp
+            mcp_registry.update_last_used(api_url)
+
+            # Load existing files
+            server_code = (mcp_path / "server.py").read_text()
+            readme = (mcp_path / "README.md").read_text()
+
+            # Get hosted URLs
+            base_url = os.getenv("SPACE_HOST", "http://localhost:7860")
+            hosted_mcp_url = f"{base_url}/mcp/{mcp_id}/messages"
+            hosted_info_url = f"{base_url}/mcp/{mcp_id}/info"
+
+            status_text = f"""♻️ **Reusing Existing MCP!**
+
+**MCP ID:** `{mcp_id}`
+**Originally Created:** {existing_mcp['created_at']}
+**Last Used:** {existing_mcp['last_used']}
+
+This MCP was already generated for this API URL. Using existing version to save time and API calls!
+
+**🌐 HTTP Transport (MCP 2025-03-26):**
+- **Endpoint:** `{hosted_mcp_url}`
+- **Info:** `{hosted_info_url}`
+- **Protocol:** JSON-RPC 2.0 over HTTP Streamable
+
+💡 **Tip:** To regenerate from scratch, check "Force Regenerate" below.
+"""
+
+            # Create ZIP file
+            zip_buffer = io.BytesIO()
+            with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for file_path in mcp_path.rglob('*'):
+                    if file_path.is_file():
+                        arcname = file_path.relative_to(mcp_path.parent)
+                        zipf.write(file_path, arcname)
+
+            zip_buffer.seek(0)
+            temp_zip = f"/tmp/{mcp_id}.zip"
+            with open(temp_zip, 'wb') as f:
+                f.write(zip_buffer.read())
+
+            connection_config = f"""# Local stdio transport:
+{{
+  "mcpServers": {{
+    "{mcp_id}": {{
+      "command": "python",
+      "args": ["server.py"]
+    }}
+  }}
+}}
+
+# HTTP transport (hosted):
+{{
+  "mcpServers": {{
+    "{mcp_id}": {{
+      "url": "{hosted_mcp_url}",
+      "transport": "http"
+    }}
+  }}
+}}"""
+
+            return (
+                status_text,
+                server_code,
+                temp_zip,
+                readme,
+                connection_config
+            )
+
+        # Generate new MCP
+        if existing_mcp:
+            progress(0.1, desc="Regenerating MCP (forced)...")
+        else:
+            progress(0.1, desc="Analyzing API...")
+
+        # Generate the MCP
+        result = await agent_factory.generate_mcp(api_url, api_key)
+
+        if result["status"] == "error":
+            return (
+                f"❌ Error: {result['error']}",
+                "",
+                None,
+                "",
+                ""
+            )
+
+        progress(0.6, desc="Generating code...")
+
+        # Get the generated files
+        mcp_id = result["mcp_id"]
+        server_code = result["server_code"]
+        readme = result["readme_content"]
+
+        progress(0.8, desc="Starting MCP server...")
+
+        # Start the MCP server
+        start_result = await mcp_host.start_mcp(mcp_id)
+
+        # Get the hosted URL (will be updated when deployed to HuggingFace)
+        base_url = os.getenv("SPACE_HOST", "http://localhost:7860")
+        hosted_mcp_url = f"{base_url}/mcp/{mcp_id}/messages"
+        hosted_info_url = f"{base_url}/mcp/{mcp_id}/info"
+
+        if not start_result["success"]:
+            status_text = f"⚠️ MCP generated but failed to start locally: {start_result.get('error')}\n\n**HTTP Endpoint:** {hosted_mcp_url}"
+        else:
+            status_text = f"""✅ **MCP Server Generated & Hosted!**
+
+**MCP ID:** `{mcp_id}`
+**Status:** {start_result['status']}
+
+**🌐 HTTP Transport (MCP 2025-03-26):**
+- **Endpoint:** `{hosted_mcp_url}`
+- **Info:** `{hosted_info_url}`
+- **Protocol:** JSON-RPC 2.0 over HTTP Streamable
+
+**📦 Local Use (stdio):**
+- Download ZIP below and extract
+- Configure in Claude Desktop (see Connection Config tab)
+
+Your MCP server is live and accessible via HTTP! 🎉
+"""
+
+        progress(0.9, desc="Creating download package...")
+
+        # Create ZIP file for download
+        zip_buffer = io.BytesIO()
+        mcp_path = Path(result["download_path"])
+
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in mcp_path.rglob('*'):
+                if file_path.is_file():
+                    arcname = file_path.relative_to(mcp_path.parent)
+                    zipf.write(file_path, arcname)
+
+        zip_buffer.seek(0)
+
+        # Save to temp file for Gradio
+        temp_zip = f"/tmp/{mcp_id}.zip"
+        with open(temp_zip, 'wb') as f:
+            f.write(zip_buffer.read())
+
+        # Create connection configs for both transports
+        connection_config = f"""# Local stdio transport (extract ZIP first):
+{{
+  "mcpServers": {{
+    "{mcp_id}": {{
+      "command": "python",
+      "args": ["server.py"]
+    }}
+  }}
+}}
+
+# HTTP transport (use hosted endpoint):
+{{
+  "mcpServers": {{
+    "{mcp_id}": {{
+      "url": "{hosted_mcp_url}",
+      "transport": "http"
+    }}
+  }}
+}}"""
+
+        progress(1.0, desc="Done!")
+
+        return (
+            status_text,
+            server_code,
+            temp_zip,
+            readme,
+            connection_config
+        )
+
+    except Exception as e:
+        return (
+            f"❌ Unexpected error: {str(e)}",
+            "",
+            None,
+            "",
+            ""
+        )
+
+
+# Build Gradio Interface
+with gr.Blocks(
+    title="MCP Generator",
+    css="""
+    .gradio-container {max-width: 1200px !important}
+    .output-box {border: 2px solid #4CAF50; border-radius: 8px; padding: 16px;}
+    """
+) as app:
+
+    gr.Markdown("""
+    # 🤖 MCP Generator
+    ## Turn Any API into an MCP Server in Seconds!
+
+    Simply enter an API URL and we'll generate a complete, working MCP server with:
+    - ✅ Automatically analyzed endpoints
+    - ✅ Generated MCP tools
+    - ✅ Complete documentation
+    - ✅ Ready to use immediately!
+
+    **Built for the MCP 1st Birthday Hackathon** 🎉
+    """)
+
+    with gr.Accordion("ℹ️ API URL Guidelines & Tips", open=False):
+        gr.Markdown("""
+        ### ✅ What Works Best:
+        - **Base API URLs** (e.g., `https://api.example.com`)
+        - **REST APIs** with clear endpoints
+        - **OpenAPI/Swagger** documented APIs
+        - **Public APIs** (no complex auth)
+
+        ### 🎯 Try These Free APIs:
+
+        **No Auth Required (Perfect for Testing!):**
+        - `https://jsonplaceholder.typicode.com` - Fake REST API (best for testing!)
+        - `https://api.github.com` - GitHub public API
+        - `https://dog.ceo/api` - Random dog images
+        - `https://catfact.ninja` - Random cat facts
+        - `https://api.coindesk.com/v1/bpi` - Bitcoin prices
+        - `https://api.ipify.org` - Get IP address
+
+        **With API Key (Free Tier):**
+        - `https://api.openweathermap.org/data/2.5` - Weather data
+        - `https://newsapi.org/v2` - News articles
+        - `https://api.stripe.com` - Payment processing (test mode)
+
+        ### 💡 Tips:
+        - **Start with jsonplaceholder.typicode.com** - always works!
+        - Paste the **base URL** (not a specific endpoint)
+        - If API needs a key, add it in the "API Key" field below
+        - Cached URLs generate instantly (try the same URL twice!)
+
+        ### ⚠️ May Not Work Well:
+        - GraphQL APIs (REST only for now)
+        - APIs requiring OAuth flows
+        - WebSocket-only APIs
+        - APIs with very complex authentication
+        """)
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("### 📝 Input")
+
+            api_url = gr.Textbox(
+                label="API URL or Documentation URL",
+                placeholder="https://api.example.com",
+                info="Enter the base URL or documentation URL of the API"
+            )
+
+            api_key = gr.Textbox(
+                label="API Key (Optional)",
+                placeholder="sk-...",
+                type="password",
+                info="If the API requires authentication"
+            )
+
+            force_regenerate = gr.Checkbox(
+                label="Force Regenerate",
+                value=False,
+                info="Regenerate even if MCP already exists for this URL (saves API calls when unchecked)"
+            )
+
+            generate_btn = gr.Button(
+                "🚀 Generate & Host MCP Server",
+                variant="primary",
+                size="lg"
+            )
+
+            with gr.Accordion("🚀 Quick Start Examples", open=True):
+                gr.Markdown("""
+                **Click to copy and paste:**
+
+                ```
+                https://jsonplaceholder.typicode.com
+                ```
+                ⭐ **Recommended first try!** Always works, no API key needed.
+
+                ---
+
+                **More examples:**
+                - `https://api.github.com` - GitHub API (no auth)
+                - `https://dog.ceo/api` - Dog images (fun!)
+                - `https://catfact.ninja` - Cat facts (simple)
+
+                💡 **Tip:** MCPs are cached - try the same URL twice to see instant results!
+                """)
+
+    gr.Markdown("---")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📊 Results")
+
+            status_output = gr.Markdown(label="Status")
+
+            with gr.Tab("Generated Code"):
+                code_output = gr.Code(
+                    label="server.py",
+                    language="python",
+                    lines=20
+                )
+
+            with gr.Tab("README"):
+                readme_output = gr.Markdown()
+
+            with gr.Tab("Connection Config"):
+                connection_output = gr.Code(
+                    label="Claude Desktop Config",
+                    language="json"
+                )
+
+            download_output = gr.File(
+                label="📦 Download Complete Package (ZIP)"
+            )
+
+    # Wire up the button
+    generate_btn.click(
+        fn=generate_and_host_mcp,
+        inputs=[api_url, api_key, force_regenerate],
+        outputs=[
+            status_output,
+            code_output,
+            download_output,
+            readme_output,
+            connection_output
+        ]
+    )
+
+    with gr.Accordion("📋 Previously Generated MCPs", open=False):
+        def get_existing_mcps():
+            """Get list of existing MCPs for display"""
+            mcps = mcp_registry.list_all()
+            if not mcps:
+                return "No MCPs generated yet. Generate your first one above! 👆"
+
+            output = "| API Name | URL | Created | Last Used |\n"
+            output += "|----------|-----|---------|----------|\n"
+            for mcp in mcps[:10]:  # Show last 10
+                api_name = mcp['api_name']
+                api_url = mcp['api_url'][:40] + "..." if len(mcp['api_url']) > 40 else mcp['api_url']
+                created = mcp['created_at'].split('T')[0]
+                last_used = mcp['last_used'].split('T')[0]
+                output += f"| {api_name} | {api_url} | {created} | {last_used} |\n"
+
+            return output
+
+        existing_mcps_display = gr.Markdown(get_existing_mcps())
+        refresh_btn = gr.Button("🔄 Refresh List", size="sm")
+        refresh_btn.click(fn=get_existing_mcps, outputs=existing_mcps_display)
+
+    gr.Markdown("""
+    ---
+    ### 🎯 How to Use Your Generated MCP
+
+    1. **Download** the ZIP file above
+    2. **Extract** it to a folder
+    3. **Add** the connection config to your Claude Desktop settings
+    4. **Restart** Claude Desktop
+
+    Your MCP server is ready to use! 🎉
+
+    ### 🚀 About This Project
+
+    This is a meta-MCP: an MCP server that generates other MCP servers!
+
+    - Built with [Gradio](https://gradio.app)
+    - Powered by [LangGraph](https://github.com/langchain-ai/langgraph) agents
+    - Uses [Anthropic's Claude](https://anthropic.com) for code generation
+    - Integrates with [MCP Fetch Server](https://github.com/modelcontextprotocol/servers)
+
+    **For MCP 1st Birthday Hackathon - Track 2: MCP in Action** 🎂
+    """)
+
+
+if __name__ == "__main__":
+    # Check for API key
+    if not ANTHROPIC_API_KEY and not OPENAI_API_KEY:
+        print("⚠️  WARNING: No API key set!")
+        print("Please set either OPENAI_API_KEY or ANTHROPIC_API_KEY in your .env file")
+        print(f"Example: echo 'OPENAI_API_KEY=your_key_here' > .env")
+
+    # Get the MCP HTTP host FastAPI app
+    mcp_fastapi_app = mcp_http_host.get_app()
+
+    # Mount MCP routes to Gradio's FastAPI instance
+    # Gradio 5.x exposes its FastAPI app via app.fastapi_app after launch
+    demo_app, local_url, share_url = app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        prevent_thread_lock=True
+    )
+
+    # Mount the MCP FastAPI app to serve MCPs
+    if hasattr(app, 'fastapi_app'):
+        # Mount all MCP routes onto the Gradio FastAPI app
+        app.fastapi_app.mount("/mcp", mcp_fastapi_app)
+
+    print("✅ MCP Generator is running!")
+    print(f"📊 Gradio UI: {local_url}")
+    print(f"🔧 MCP Endpoints: {local_url}/mcps")
+    print(f"🌐 Generated MCPs will be accessible at: {local_url}/mcp/{{mcp_id}}/messages")
+
+    # Keep the server running
+    import threading
+    threading.Event().wait()

requirements.txt

@@ -1,11 +1,12 @@
-gradio
-anthropic
-openai
-mcp
-langgraph
-jinja2
-pydantic
-python-dotenv
-aiohttp
-uvicorn
-fastapi
+gradio
+anthropic
+openai
+mcp
+langgraph
+jinja2
+pydantic
+python-dotenv
+aiohttp
+fastapi
+uvicorn
+httpx

src/agents/code_generator.py

@@ -79,7 +79,7 @@ Only include JSON, no other text."""
         # Setup Jinja2 environment
         env = Environment(loader=FileSystemLoader(TEMPLATES_DIR))
 
-        # Generate server code
+        # Generate stdio server code (for local use/download)
         server_template = env.get_template("mcp_server_template.py.jinja")
         server_code = server_template.render(
             api_name=state['api_name'],
@@ -89,6 +89,16 @@ Only include JSON, no other text."""
             tools=tools
         )
 
+        # Generate HTTP server code (for hosting in Space)
+        http_template = env.get_template("mcp_server_http_template.py.jinja")
+        http_server_code = http_template.render(
+            api_name=state['api_name'],
+            api_url=state['api_url'],
+            mcp_id=mcp_id,
+            timestamp=datetime.now().isoformat(),
+            tools=tools
+        )
+
         # Generate README
         readme_template = env.get_template("readme_template.md.jinja")
         readme_content = readme_template.render(
@@ -97,7 +107,7 @@ Only include JSON, no other text."""
             server_name=mcp_id,
             timestamp=datetime.now().isoformat(),
             tools=tools,
-            hosted_url=f"http://localhost:8000/mcps/{mcp_id}",  # Will be updated when hosted
+            hosted_url=f"https://your-space.hf.space/mcp/{mcp_id}",  # Will be updated when deployed
             auth_type=state['auth_type'],
             rate_limits="Check API documentation"
         )
@@ -105,7 +115,9 @@ Only include JSON, no other text."""
         # Generate requirements.txt
         requirements = """mcp>=1.1.0
 httpx>=0.27.0
-asyncio
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0
 """
 
         # Save to hosted_mcps directory
@@ -113,6 +125,7 @@ asyncio
         mcp_dir.mkdir(exist_ok=True)
 
         (mcp_dir / "server.py").write_text(server_code)
+        (mcp_dir / "server_http.py").write_text(http_server_code)
         (mcp_dir / "README.md").write_text(readme_content)
         (mcp_dir / "requirements.txt").write_text(requirements)
 

src/mcp_host.py

@@ -5,7 +5,6 @@ import subprocess
 import signal
 from pathlib import Path
 from typing import Dict, Optional
-import psutil
 
 from .config import HOSTED_MCPS_DIR
 

src/mcp_http_host.py

@@ -0,0 +1,139 @@
+"""HTTP Host for Generated MCPs - Makes them accessible via web endpoints"""
+
+import asyncio
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from pathlib import Path
+import importlib.util
+import sys
+from typing import Dict, Any
+
+from .config import HOSTED_MCPS_DIR
+
+class MCPHTTPHost:
+    """Hosts multiple MCP servers via HTTP endpoints"""
+
+    def __init__(self):
+        self.app = FastAPI(title="MCP Generator - Hosted MCPs")
+        self.loaded_mcps: Dict[str, Any] = {}
+
+        # Add root endpoint
+        @self.app.get("/")
+        async def root():
+            return {
+                "service": "MCP Generator",
+                "hosted_mcps": list(self.loaded_mcps.keys()),
+                "endpoints": {
+                    "list_all": "/mcps",
+                    "mcp_tools": "/mcp/{mcp_id}/tools",
+                    "mcp_call": "/mcp/{mcp_id}/call",
+                    "mcp_health": "/mcp/{mcp_id}/health"
+                }
+            }
+
+        @self.app.get("/mcps")
+        async def list_mcps():
+            """List all hosted MCPs"""
+            return {
+                "mcps": [
+                    {
+                        "mcp_id": mcp_id,
+                        "endpoints": {
+                            "tools": f"/mcp/{mcp_id}/tools",
+                            "call": f"/mcp/{mcp_id}/call",
+                            "health": f"/mcp/{mcp_id}/health"
+                        }
+                    }
+                    for mcp_id in self.loaded_mcps.keys()
+                ]
+            }
+
+        self._setup_dynamic_routes()
+
+    def _setup_dynamic_routes(self):
+        """Set up dynamic routes for all MCPs"""
+
+        @self.app.get("/mcp/{mcp_id}/tools")
+        async def get_tools(mcp_id: str):
+            """Get tools for a specific MCP"""
+            if mcp_id not in self.loaded_mcps:
+                # Try to load the MCP
+                if not self.load_mcp(mcp_id):
+                    raise HTTPException(status_code=404, detail=f"MCP {mcp_id} not found")
+
+            mcp_module = self.loaded_mcps[mcp_id]
+            if hasattr(mcp_module, 'get_tools'):
+                return {"tools": await mcp_module.get_tools()}
+            raise HTTPException(status_code=500, detail="MCP does not expose tools")
+
+        @self.app.post("/mcp/{mcp_id}/call")
+        async def call_tool(mcp_id: str, tool_call: dict):
+            """Call a tool in a specific MCP"""
+            if mcp_id not in self.loaded_mcps:
+                if not self.load_mcp(mcp_id):
+                    raise HTTPException(status_code=404, detail=f"MCP {mcp_id} not found")
+
+            mcp_module = self.loaded_mcps[mcp_id]
+            if hasattr(mcp_module, 'call_tool'):
+                result = await mcp_module.call_tool(
+                    tool_call.get('name'),
+                    tool_call.get('arguments', {})
+                )
+                return {"content": result}
+            raise HTTPException(status_code=500, detail="MCP does not support tool calls")
+
+        @self.app.get("/mcp/{mcp_id}/health")
+        async def health_check(mcp_id: str):
+            """Health check for a specific MCP"""
+            if mcp_id in self.loaded_mcps:
+                return {"status": "healthy", "mcp_id": mcp_id, "loaded": True}
+
+            # Try to load
+            if self.load_mcp(mcp_id):
+                return {"status": "healthy", "mcp_id": mcp_id, "loaded": True}
+
+            return {"status": "not_found", "mcp_id": mcp_id, "loaded": False}
+
+    def load_mcp(self, mcp_id: str) -> bool:
+        """Dynamically load an MCP server module"""
+        mcp_path = HOSTED_MCPS_DIR / mcp_id / "server_http.py"
+
+        if not mcp_path.exists():
+            return False
+
+        try:
+            # Load the module dynamically
+            spec = importlib.util.spec_from_file_location(f"mcp_{mcp_id}", mcp_path)
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[f"mcp_{mcp_id}"] = module
+                spec.loader.exec_module(module)
+
+                self.loaded_mcps[mcp_id] = module
+                return True
+        except Exception as e:
+            print(f"Failed to load MCP {mcp_id}: {e}")
+            return False
+
+        return False
+
+    def load_all_mcps(self):
+        """Load all available MCPs from the hosted_mcps directory"""
+        if not HOSTED_MCPS_DIR.exists():
+            return
+
+        for mcp_dir in HOSTED_MCPS_DIR.iterdir():
+            if mcp_dir.is_dir():
+                mcp_id = mcp_dir.name
+                self.load_mcp(mcp_id)
+
+        print(f"✅ Loaded {len(self.loaded_mcps)} MCPs")
+
+    def get_app(self) -> FastAPI:
+        """Get the FastAPI app instance"""
+        self.load_all_mcps()
+        return self.app
+
+
+# Global instance
+mcp_http_host = MCPHTTPHost()

src/templates/mcp_server_http_template.py.jinja

@@ -0,0 +1,262 @@
+"""
+Generated MCP Server for {{ api_name }} (HTTP Streamable Transport - MCP 2025-03-26)
+Auto-generated by MCP Generator
+
+API URL: {{ api_url }}
+Generated: {{ timestamp }}
+Hosted at: /mcp/{{ mcp_id }}/
+
+This server implements MCP specification 2025-03-26 with HTTP streamable transport.
+Uses JSON-RPC 2.0 protocol over HTTP as specified in the MCP standard.
+"""
+
+import asyncio
+import json
+from typing import Any
+from mcp.server import Server
+from mcp.types import Tool, TextContent
+import httpx
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+import uvicorn
+
+# Initialize MCP server
+mcp_server = Server("{{ mcp_id }}")
+
+# Initialize FastAPI app for HTTP transport
+app = FastAPI(title="{{ api_name }} MCP Server")
+
+@mcp_server.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available MCP tools"""
+    return [
+        {% for tool in tools %}
+        Tool(
+            name="{{ tool.name }}",
+            description="{{ tool.description }}",
+            inputSchema={
+                "type": "object",
+                "properties": {{ tool.parameters | tojson }},
+                "required": {{ tool.required | tojson }}
+            }
+        ){% if not loop.last %},{% endif %}
+        {% endfor %}
+    ]
+
+@mcp_server.call_tool()
+async def call_tool(name: str, arguments: Any) -> list[TextContent]:
+    """Handle MCP tool calls"""
+    {% for tool in tools %}
+    {% if loop.first %}if{% else %}elif{% endif %} name == "{{ tool.name }}":
+        return await {{ tool.function_name }}(arguments)
+    {% endfor %}
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+
+{% for tool in tools %}
+async def {{ tool.function_name }}(args: dict) -> list[TextContent]:
+    """{{ tool.description }}"""
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            {% if tool.method == "GET" %}
+            response = await client.get(
+                "{{ tool.endpoint }}",
+                params=args,
+                headers={{ tool.headers | tojson }}
+            )
+            {% elif tool.method == "POST" %}
+            response = await client.post(
+                "{{ tool.endpoint }}",
+                json=args,
+                headers={{ tool.headers | tojson }}
+            )
+            {% elif tool.method == "PUT" %}
+            response = await client.put(
+                "{{ tool.endpoint }}",
+                json=args,
+                headers={{ tool.headers | tojson }}
+            )
+            {% elif tool.method == "DELETE" %}
+            response = await client.delete(
+                "{{ tool.endpoint }}",
+                params=args,
+                headers={{ tool.headers | tojson }}
+            )
+            {% endif %}
+
+            response.raise_for_status()
+
+            # Format response
+            content = response.json() if response.headers.get("content-type", "").startswith("application/json") else response.text
+
+            return [TextContent(
+                type="text",
+                text=json.dumps(content, indent=2) if isinstance(content, dict) else str(content)
+            )]
+
+    except httpx.HTTPError as e:
+        return [TextContent(
+            type="text",
+            text=f"Error calling API: {str(e)}"
+        )]
+    except Exception as e:
+        return [TextContent(
+            type="text",
+            text=f"Unexpected error: {str(e)}"
+        )]
+
+{% endfor %}
+
+# HTTP Streamable Transport Implementation (MCP 2025-03-26 spec)
+class MCPMessageHandler:
+    """Handles MCP JSON-RPC messages over HTTP"""
+
+    async def handle_message(self, message: dict) -> dict:
+        """Process MCP JSON-RPC 2.0 message"""
+        method = message.get("method")
+        params = message.get("params", {})
+        msg_id = message.get("id")
+
+        try:
+            if method == "tools/list":
+                tools = await list_tools()
+                return {
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "result": {
+                        "tools": [
+                            {
+                                "name": tool.name,
+                                "description": tool.description,
+                                "inputSchema": tool.inputSchema
+                            }
+                            for tool in tools
+                        ]
+                    }
+                }
+
+            elif method == "tools/call":
+                tool_name = params.get("name")
+                arguments = params.get("arguments", {})
+
+                result = await call_tool(tool_name, arguments)
+
+                return {
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "result": {
+                        "content": [
+                            {"type": item.type, "text": item.text}
+                            for item in result
+                        ]
+                    }
+                }
+
+            elif method == "initialize":
+                return {
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "result": {
+                        "protocolVersion": "2025-03-26",
+                        "serverInfo": {
+                            "name": "{{ mcp_id }}",
+                            "version": "1.0.0"
+                        },
+                        "capabilities": {
+                            "tools": {}
+                        }
+                    }
+                }
+
+            else:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": msg_id,
+                    "error": {
+                        "code": -32601,
+                        "message": f"Method not found: {method}"
+                    }
+                }
+
+        except Exception as e:
+            return {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                }
+            }
+
+message_handler = MCPMessageHandler()
+
+@app.post("/mcp/{{ mcp_id }}/messages")
+async def handle_mcp_messages(request: Request):
+    """
+    MCP HTTP Streamable Transport endpoint (MCP 2025-03-26)
+    Accepts JSON-RPC 2.0 messages and returns streaming responses
+    """
+    try:
+        body = await request.json()
+
+        # Handle single message or batch
+        messages = body if isinstance(body, list) else [body]
+
+        async def generate_responses():
+            for message in messages:
+                response = await message_handler.handle_message(message)
+                yield json.dumps(response) + "\n"
+
+        return StreamingResponse(
+            generate_responses(),
+            media_type="application/jsonrpc+json",
+            headers={"Cache-Control": "no-cache"}
+        )
+
+    except Exception as e:
+        return {
+            "jsonrpc": "2.0",
+            "error": {
+                "code": -32700,
+                "message": f"Parse error: {str(e)}"
+            }
+        }
+
+@app.get("/mcp/{{ mcp_id }}/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "mcp_id": "{{ mcp_id }}",
+        "protocol": "MCP 2025-03-26",
+        "transport": "HTTP Streamable"
+    }
+
+@app.get("/mcp/{{ mcp_id }}/info")
+async def server_info():
+    """Get server information"""
+    tools = await list_tools()
+    return {
+        "serverInfo": {
+            "name": "{{ mcp_id }}",
+            "version": "1.0.0",
+            "description": "Generated MCP server for {{ api_name }}"
+        },
+        "capabilities": {
+            "tools": {}
+        },
+        "tools": [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "inputSchema": tool.inputSchema
+            }
+            for tool in tools
+        ]
+    }
+
+if __name__ == "__main__":
+    # Run on dynamic port for HuggingFace Spaces
+    import os
+    port = int(os.getenv("PORT", 8000))
+    uvicorn.run(app, host="0.0.0.0", port=port)