Upload 17 files

README.md

@@ -1,13 +1,180 @@
----
-title: Mcp Generator
-emoji: 📊
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 6.0.1
-app_file: app.py
-pinned: false
-license: other
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: MCP Generator
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+tags:
+  - mcp
+  - model-context-protocol
+  - code-generation
+  - api
+  - agents
+  - langgraph
+---
+
+# 🤖 MCP Generator
+
+**Turn Any API into an MCP Server in Seconds!**
+
+Built for the **MCP 1st Birthday Hackathon** - Track 2: MCP in Action 🎉
+
+## 🎯 What is This?
+
+A **meta-MCP** that generates MCP servers from any API! This is:
+- ✅ An **MCP server itself** (uses MCP Fetch Server)
+- ✅ A **code generator** (powered by LangGraph agents)
+- ✅ A **one-click deployment tool** (instant MCP hosting)
+- ✅ **Non-technical friendly** (no terminal commands needed!)
+
+## ✨ Features
+
+- **🔍 Automatic API Analysis** - Just provide a URL, we analyze the API structure
+- **🤖 AI-Powered Code Generation** - Claude generates complete, working MCP servers
+- **📦 Complete Package** - Get server code, README, and config files
+- **🚀 Instant Hosting** - Your MCP runs immediately in our Space
+- **📥 Download Option** - Self-host later if you want
+- **🎨 Beautiful UI** - Built with Gradio for ease of use
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────┐
+│    Gradio Frontend          │
+└──────────┬──────────────────┘
+           │
+┌──────────▼──────────────────┐
+│  LangGraph Agent Factory    │
+│  ┌────────────────────────┐ │
+│  │ API Analyzer Agent     │ │  ← Uses Fetch MCP
+│  └────────────────────────┘ │
+│  ┌────────────────────────┐ │
+│  │ Code Generator Agent   │ │  ← Uses Claude API
+│  └────────────────────────┘ │
+└──────────┬──────────────────┘
+           │
+┌──────────▼──────────────────┐
+│   Generated MCP Server      │
+│   • stdio transport         │
+│   • Complete documentation  │
+│   • Ready to deploy         │
+└─────────────────────────────┘
+```
+
+## 🚀 Quick Start
+
+### Try it on HuggingFace Spaces
+
+👉 **[Launch MCP Generator](https://huggingface.co/spaces/MCP-1st-Birthday/mcp-generator)** 👈
+
+### Run Locally
+
+```bash
+# Clone the repo
+git clone https://github.com/visprogithub/MCP_Generator_Agent.git
+cd MCP_Generator_Agent
+
+# Install dependencies
+npm install -g npx  # For MCP Fetch Server
+pip install -r requirements.txt
+
+# Set up API key
+echo "ANTHROPIC_API_KEY=your_key_here" > .env
+
+# Run the app
+python app.py
+```
+
+Then open http://localhost:7860 in your browser!
+
+## 📖 How to Use
+
+1. **Enter an API URL** (e.g., `https://api.github.com`)
+2. **Click "Generate & Host MCP Server"**
+3. **Download the ZIP** or copy the connection config
+4. **Use in Claude Desktop!**
+
+That's it! ✨
+
+## 🎓 Example APIs to Try
+
+- `https://api.github.com` - GitHub API
+- `https://api.stripe.com` - Stripe Payment API
+- `https://api.openweathermap.org` - Weather Data
+- `https://jsonplaceholder.typicode.com` - Fake REST API (for testing)
+
+## 🛠️ Technology Stack
+
+- **Frontend:** [Gradio 4](https://gradio.app) - Beautiful web UI
+- **Agents:** [LangGraph](https://github.com/langchain-ai/langgraph) - Agent orchestration
+- **LLM:** [Anthropic Claude](https://anthropic.com) - Code generation
+- **MCP Client:** [@modelcontextprotocol/server-fetch](https://github.com/modelcontextprotocol/servers) - Fetch API docs
+- **MCP Server:** [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk) - Generated servers
+
+## 🎯 MCP 1st Birthday Hackathon
+
+This project demonstrates:
+
+✅ **Using MCP** - Integrates Fetch MCP for API analysis
+✅ **Providing MCP** - Generates working MCP servers
+✅ **Real-world Impact** - Makes MCP development accessible to everyone
+✅ **Creativity** - Meta-MCP that builds MCPs using MCPs!
+✅ **Polish** - Beautiful UI, complete docs, one-click experience
+
+### Track 2: MCP in Action
+
+Category: **Productivity**
+
+This tool makes developers and non-technical users 10x more productive by eliminating the manual work of creating MCP servers.
+
+## 📁 Project Structure
+
+```
+MCP_Generator_Agent/
+├── app.py                  # Main Gradio application
+├── src/
+│   ├── agents/            # LangGraph agents
+│   │   ├── factory.py     # Agent orchestration
+│   │   ├── api_analyzer.py
+│   │   └── code_generator.py
+│   ├── mcp_clients/       # MCP client wrappers
+│   │   └── fetch_client.py
+│   ├── templates/         # Code templates
+│   │   ├── mcp_server_template.py.jinja
+│   │   └── readme_template.md.jinja
+│   ├── hosted_mcps/       # Generated MCPs
+│   ├── mcp_host.py        # MCP hosting manager
+│   └── config.py          # Configuration
+├── requirements.txt
+└── README.md
+```
+
+## 🤝 Contributing
+
+This is a hackathon project, but contributions are welcome! Feel free to:
+
+- Report bugs
+- Suggest features
+- Submit pull requests
+- Share your generated MCPs!
+
+## 📄 License
+
+MIT License - See LICENSE file for details
+
+## 🙏 Acknowledgments
+
+- [Anthropic](https://anthropic.com) for Claude and MCP
+- [Gradio](https://gradio.app) for the amazing UI framework
+- [LangGraph](https://github.com/langchain-ai/langgraph) for agent orchestration
+- The entire MCP community! 🎂
+
+---
+
+**Made with ❤️ for the MCP 1st Birthday Hackathon**
+
+🔗 [HuggingFace Space](https://huggingface.co/spaces/MCP-1st-Birthday/mcp-generator) | 🔗 [GitHub](https://github.com/visprogithub/MCP_Generator_Agent)

app.py

@@ -0,0 +1,365 @@
+"""
+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",
+    theme=gr.themes.Soft(),
+    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.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("📚 Examples & Tips", open=False):
+                gr.Markdown("""
+                **Try these APIs:**
+                - `https://jsonplaceholder.typicode.com` - Fake REST API (great for testing!)
+                - `https://api.github.com` - GitHub API
+                - `https://api.stripe.com` - Stripe API
+                - `https://api.openweathermap.org` - Weather API
+
+                **💡 Tips:**
+                - MCPs are cached by URL to save API calls
+                - Check "Force Regenerate" to create a fresh version
+                - Generated MCPs use stdio transport (works locally)
+                """)
+
+    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
+    )

requirements.txt

@@ -0,0 +1,11 @@
+gradio==4.44.0
+anthropic==0.39.0
+openai==1.54.3
+mcp==1.1.2
+langgraph==0.2.45
+jinja2==3.1.4
+pydantic==2.9.2
+python-dotenv==1.0.1
+aiohttp==3.10.10
+uvicorn==0.32.0
+fastapi==0.115.4

src/__init__.py

@@ -0,0 +1,3 @@
+"""MCP Generator - Generate MCP servers from any API"""
+
+__version__ = "0.1.0"

src/agents/__init__.py

@@ -0,0 +1,6 @@
+"""Agent factory for MCP generation"""
+
+from .factory import AgentFactory
+from .state import AgentState
+
+__all__ = ["AgentFactory", "AgentState"]

src/agents/api_analyzer.py

@@ -0,0 +1,99 @@
+"""API Analyzer Agent - Analyzes API documentation and structure"""
+
+import asyncio
+import json
+import re
+from .state import AgentState
+from ..mcp_clients.fetch_client import fetch_url
+from ..llm_client import get_llm_client
+
+
+async def analyze_api(state: AgentState) -> AgentState:
+    """Analyze the API and extract structure
+
+    Args:
+        state: Current agent state
+
+    Returns:
+        Updated state with API analysis
+    """
+    state["status"] = "analyzing_api"
+
+    try:
+        # Try to fetch API documentation
+        api_url = state["api_url"]
+
+        # Common patterns for API doc URLs
+        doc_urls = [
+            api_url,
+            f"{api_url}/docs",
+            f"{api_url}/api-docs",
+            f"{api_url}/swagger.json",
+            f"{api_url}/openapi.json",
+        ]
+
+        api_content = None
+        successful_url = None
+
+        # Try to fetch from potential doc URLs
+        for doc_url in doc_urls:
+            try:
+                result = await fetch_url(doc_url)
+                if result.get("success"):
+                    api_content = result["content"]
+                    successful_url = doc_url
+                    break
+            except Exception:
+                continue
+
+        if not api_content:
+            # If we can't fetch docs, use Claude to infer structure
+            api_content = f"No documentation found for {api_url}"
+
+        state["api_docs"] = api_content
+        state["api_docs_url"] = successful_url
+
+        # Use LLM to analyze the API
+        llm = get_llm_client()
+
+        analysis_prompt = f"""Analyze this API and extract information:
+
+API URL: {api_url}
+Documentation: {api_content[:5000]}  # Limit to avoid token limits
+
+Please provide a JSON response with:
+1. api_name: A short name for this API
+2. api_description: Brief description of what the API does
+3. endpoints: List of 3-5 most useful endpoints with structure:
+   - path: endpoint path
+   - method: HTTP method
+   - description: what it does
+   - parameters: dict of parameter names and types
+4. auth_type: "bearer", "api_key", "basic", or "none"
+
+Format as valid JSON only, no other text."""
+
+        try:
+            analysis = await llm.generate_json(analysis_prompt, max_tokens=2000)
+        except Exception:
+            # Fallback analysis if JSON parsing fails
+            analysis = {
+                "api_name": api_url.split("//")[-1].split("/")[0].replace(".", "-"),
+                "api_description": f"API at {api_url}",
+                "endpoints": [],
+                "auth_type": "api_key"
+            }
+
+        # Update state
+        state["api_name"] = analysis.get("api_name", "unknown-api")
+        state["api_description"] = analysis.get("api_description", "")
+        state["endpoints"] = analysis.get("endpoints", [])
+        state["auth_type"] = analysis.get("auth_type", "none")
+        state["status"] = "analyzed"
+
+        return state
+
+    except Exception as e:
+        state["status"] = "error"
+        state["error"] = f"Analysis failed: {str(e)}"
+        return state

src/agents/code_generator.py

@@ -0,0 +1,142 @@
+"""Code Generator Agent - Generates MCP server code"""
+
+import asyncio
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader
+import re
+
+from .state import AgentState
+from ..config import TEMPLATES_DIR, HOSTED_MCPS_DIR
+from ..mcp_registry import mcp_registry
+from ..llm_client import get_llm_client
+
+
+async def generate_code(state: AgentState) -> AgentState:
+    """Generate MCP server code from API analysis
+
+    Args:
+        state: Current agent state
+
+    Returns:
+        Updated state with generated code
+    """
+    state["status"] = "generating_code"
+
+    try:
+        # Generate unique MCP ID
+        mcp_id = f"{state['api_name']}-{uuid.uuid4().hex[:8]}"
+        state["mcp_id"] = mcp_id
+
+        # Use LLM to generate detailed tool specifications
+        llm = get_llm_client()
+
+        code_gen_prompt = f"""Generate Python MCP tools for this API:
+
+API Name: {state['api_name']}
+Description: {state['api_description']}
+Base URL: {state['api_url']}
+Auth Type: {state['auth_type']}
+Endpoints: {json.dumps(state['endpoints'], indent=2)}
+
+For each endpoint, create a tool specification with:
+- name: snake_case function name
+- description: what the tool does
+- function_name: Python function name
+- endpoint: full URL path
+- method: HTTP method (GET/POST)
+- parameters: dict of param names to schema (type, description)
+- required: list of required param names
+- headers: dict of headers needed (include auth if needed)
+
+Provide response as valid JSON array of tool objects.
+Only include JSON, no other text."""
+
+        try:
+            # Try to get JSON response
+            tools_text = await llm.generate(code_gen_prompt, max_tokens=3000)
+            json_match = re.search(r'\[.*\]', tools_text, re.DOTALL)
+
+            if json_match:
+                tools = json.loads(json_match.group())
+            else:
+                raise ValueError("No JSON array found")
+        except Exception:
+            # Fallback to basic tools
+            tools = [{
+                "name": f"{state['api_name']}_api_call",
+                "description": f"Make a call to {state['api_name']} API",
+                "function_name": "api_call",
+                "endpoint": state['api_url'],
+                "method": "GET",
+                "parameters": {},
+                "required": [],
+                "headers": {}
+            }]
+
+        # Setup Jinja2 environment
+        env = Environment(loader=FileSystemLoader(TEMPLATES_DIR))
+
+        # Generate server code
+        server_template = env.get_template("mcp_server_template.py.jinja")
+        server_code = server_template.render(
+            api_name=state['api_name'],
+            api_url=state['api_url'],
+            server_name=mcp_id,
+            timestamp=datetime.now().isoformat(),
+            tools=tools
+        )
+
+        # Generate README
+        readme_template = env.get_template("readme_template.md.jinja")
+        readme_content = readme_template.render(
+            api_name=state['api_name'],
+            api_url=state['api_url'],
+            server_name=mcp_id,
+            timestamp=datetime.now().isoformat(),
+            tools=tools,
+            hosted_url=f"http://localhost:8000/mcps/{mcp_id}",  # Will be updated when hosted
+            auth_type=state['auth_type'],
+            rate_limits="Check API documentation"
+        )
+
+        # Generate requirements.txt
+        requirements = """mcp>=1.1.0
+httpx>=0.27.0
+asyncio
+"""
+
+        # Save to hosted_mcps directory
+        mcp_dir = HOSTED_MCPS_DIR / mcp_id
+        mcp_dir.mkdir(exist_ok=True)
+
+        (mcp_dir / "server.py").write_text(server_code)
+        (mcp_dir / "README.md").write_text(readme_content)
+        (mcp_dir / "requirements.txt").write_text(requirements)
+
+        # Register in the MCP registry
+        mcp_registry.register(
+            api_url=state['api_url'],
+            mcp_id=mcp_id,
+            api_name=state['api_name'],
+            metadata={
+                'auth_type': state['auth_type'],
+                'endpoints_count': len(state['endpoints'])
+            }
+        )
+
+        # Update state
+        state["server_code"] = server_code
+        state["readme_content"] = readme_content
+        state["requirements"] = requirements
+        state["download_path"] = str(mcp_dir)
+        state["status"] = "completed"
+
+        return state
+
+    except Exception as e:
+        state["status"] = "error"
+        state["error"] = f"Code generation failed: {str(e)}"
+        return state

src/agents/factory.py

@@ -0,0 +1,81 @@
+"""Agent Factory - Orchestrates MCP generation using LangGraph"""
+
+import asyncio
+from typing import Dict, Any
+from langgraph.graph import StateGraph, END
+
+from .state import AgentState
+from .api_analyzer import analyze_api
+from .code_generator import generate_code
+from ..config import LLM_PROVIDER, ANTHROPIC_API_KEY, OPENAI_API_KEY
+
+
+class AgentFactory:
+    """Factory for creating and running MCP generation agents"""
+
+    def __init__(self):
+        """Initialize the agent factory"""
+        # Check that we have at least one API key configured
+        if LLM_PROVIDER == "anthropic" and not ANTHROPIC_API_KEY:
+            raise ValueError("ANTHROPIC_API_KEY is required when LLM_PROVIDER=anthropic")
+        elif LLM_PROVIDER == "openai" and not OPENAI_API_KEY:
+            raise ValueError("OPENAI_API_KEY is required when LLM_PROVIDER=openai")
+
+        self.graph = self._build_graph()
+
+    def _build_graph(self) -> StateGraph:
+        """Build the LangGraph workflow"""
+
+        # Create the graph
+        workflow = StateGraph(AgentState)
+
+        # Add nodes (agents)
+        workflow.add_node("analyze_api", analyze_api)
+        workflow.add_node("generate_code", generate_code)
+
+        # Define edges (workflow)
+        workflow.set_entry_point("analyze_api")
+        workflow.add_edge("analyze_api", "generate_code")
+        workflow.add_edge("generate_code", END)
+
+        return workflow.compile()
+
+    async def generate_mcp(self, api_url: str, api_key: str = None) -> AgentState:
+        """Generate an MCP server from an API URL
+
+        Args:
+            api_url: The API URL to analyze
+            api_key: Optional API key for the target API
+
+        Returns:
+            Final agent state with generated MCP
+        """
+
+        # Initial state
+        initial_state: AgentState = {
+            "api_url": api_url,
+            "api_key": api_key,
+            "api_docs": None,
+            "api_docs_url": None,
+            "api_name": "",
+            "api_description": "",
+            "endpoints": [],
+            "auth_type": "none",
+            "server_code": "",
+            "readme_content": "",
+            "requirements": "",
+            "mcp_id": "",
+            "hosted_url": "",
+            "download_path": "",
+            "status": "initializing",
+            "error": None
+        }
+
+        # Run the graph
+        try:
+            final_state = await self.graph.ainvoke(initial_state)
+            return final_state
+        except Exception as e:
+            initial_state["status"] = "failed"
+            initial_state["error"] = str(e)
+            return initial_state

src/agents/state.py

@@ -0,0 +1,35 @@
+"""Agent state definitions"""
+
+from typing import TypedDict, Optional, List, Dict, Any
+
+
+class AgentState(TypedDict):
+    """State shared across all agents"""
+
+    # Input
+    api_url: str
+    api_key: Optional[str]
+
+    # Fetched data
+    api_docs: Optional[str]
+    api_docs_url: Optional[str]
+
+    # Analysis
+    api_name: str
+    api_description: str
+    endpoints: List[Dict[str, Any]]
+    auth_type: str
+
+    # Generated code
+    server_code: str
+    readme_content: str
+    requirements: str
+
+    # Output
+    mcp_id: str
+    hosted_url: str
+    download_path: str
+
+    # Status
+    status: str
+    error: Optional[str]

src/config.py

@@ -0,0 +1,28 @@
+"""Configuration management"""
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Project paths
+PROJECT_ROOT = Path(__file__).parent.parent
+TEMPLATES_DIR = PROJECT_ROOT / "src" / "templates"
+HOSTED_MCPS_DIR = PROJECT_ROOT / "src" / "hosted_mcps"
+
+# LLM Configuration
+LLM_PROVIDER = os.getenv("LLM_PROVIDER", "openai").lower()  # "anthropic" or "openai"
+
+# API Keys
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
+
+# MCP Server settings
+MCP_HOST = "0.0.0.0"
+MCP_PORT_RANGE_START = 8100
+MCP_PORT_RANGE_END = 8200
+
+# Ensure directories exist
+HOSTED_MCPS_DIR.mkdir(exist_ok=True)

src/llm_client.py

@@ -0,0 +1,93 @@
+"""Unified LLM client supporting multiple providers"""
+
+import json
+import re
+from typing import Optional
+from anthropic import Anthropic
+from openai import OpenAI
+
+from .config import LLM_PROVIDER, ANTHROPIC_API_KEY, OPENAI_API_KEY
+
+
+class LLMClient:
+    """Unified client for different LLM providers"""
+
+    def __init__(self, provider: str = None):
+        """Initialize LLM client
+
+        Args:
+            provider: "anthropic" or "openai". If None, uses config default.
+        """
+        self.provider = provider or LLM_PROVIDER
+
+        if self.provider == "anthropic":
+            if not ANTHROPIC_API_KEY:
+                raise ValueError("ANTHROPIC_API_KEY not set")
+            self.client = Anthropic(api_key=ANTHROPIC_API_KEY)
+            self.model = "claude-3-5-sonnet-20241022"
+
+        elif self.provider == "openai":
+            if not OPENAI_API_KEY:
+                raise ValueError("OPENAI_API_KEY not set")
+            self.client = OpenAI(api_key=OPENAI_API_KEY)
+            self.model = "gpt-4o"  # or "gpt-4o-mini" for cheaper
+
+        else:
+            raise ValueError(f"Unknown provider: {self.provider}")
+
+    async def generate(self, prompt: str, max_tokens: int = 2000) -> str:
+        """Generate text from prompt
+
+        Args:
+            prompt: The prompt to send
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Generated text
+        """
+        if self.provider == "anthropic":
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                messages=[{
+                    "role": "user",
+                    "content": prompt
+                }]
+            )
+            return response.content[0].text
+
+        elif self.provider == "openai":
+            response = self.client.chat.completions.create(
+                model=self.model,
+                max_tokens=max_tokens,
+                messages=[{
+                    "role": "user",
+                    "content": prompt
+                }]
+            )
+            return response.choices[0].message.content
+
+    async def generate_json(self, prompt: str, max_tokens: int = 3000) -> dict:
+        """Generate JSON from prompt
+
+        Args:
+            prompt: The prompt to send
+            max_tokens: Maximum tokens to generate
+
+        Returns:
+            Parsed JSON dict
+        """
+        text = await self.generate(prompt, max_tokens)
+
+        # Extract JSON from response (might be wrapped in markdown)
+        json_match = re.search(r'\{.*\}|\[.*\]', text, re.DOTALL)
+        if json_match:
+            return json.loads(json_match.group())
+        else:
+            raise ValueError(f"No valid JSON found in response: {text[:200]}")
+
+
+# Global instance
+def get_llm_client() -> LLMClient:
+    """Get configured LLM client"""
+    return LLMClient()

src/mcp_clients/__init__.py

@@ -0,0 +1,5 @@
+"""MCP client implementations"""
+
+from .fetch_client import FetchMCPClient, fetch_url
+
+__all__ = ["FetchMCPClient", "fetch_url"]

src/mcp_clients/fetch_client.py

@@ -0,0 +1,86 @@
+"""Fetch MCP Client - Wrapper for @modelcontextprotocol/server-fetch"""
+
+import asyncio
+import json
+from typing import Optional
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+
+class FetchMCPClient:
+    """Client for interacting with the Fetch MCP server"""
+
+    def __init__(self):
+        self.session: Optional[ClientSession] = None
+        self.read_stream = None
+        self.write_stream = None
+
+    async def connect(self):
+        """Connect to the Fetch MCP server"""
+        server_params = StdioServerParameters(
+            command="npx",
+            args=["-y", "@modelcontextprotocol/server-fetch"],
+            env=None
+        )
+
+        self.read_stream, self.write_stream = await stdio_client(server_params)
+        self.session = ClientSession(self.read_stream, self.write_stream)
+        await self.session.initialize()
+
+    async def disconnect(self):
+        """Disconnect from the MCP server"""
+        if self.session:
+            await self.session.__aexit__(None, None, None)
+
+    async def fetch_url(self, url: str) -> dict:
+        """Fetch content from a URL
+
+        Args:
+            url: The URL to fetch
+
+        Returns:
+            dict with 'content' and 'metadata'
+        """
+        if not self.session:
+            await self.connect()
+
+        result = await self.session.call_tool("fetch", arguments={"url": url})
+
+        # Parse the result
+        if result and result.content:
+            content = result.content[0].text if result.content else ""
+            return {
+                "content": content,
+                "url": url,
+                "success": True
+            }
+
+        return {
+            "content": "",
+            "url": url,
+            "success": False,
+            "error": "Failed to fetch content"
+        }
+
+    async def __aenter__(self):
+        """Async context manager entry"""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit"""
+        await self.disconnect()
+
+
+# Convenience function
+async def fetch_url(url: str) -> dict:
+    """Fetch content from a URL using Fetch MCP
+
+    Args:
+        url: The URL to fetch
+
+    Returns:
+        dict with content and metadata
+    """
+    async with FetchMCPClient() as client:
+        return await client.fetch_url(url)

src/mcp_host.py

@@ -0,0 +1,175 @@
+"""MCP Host Manager - Runs generated MCP servers in our Space"""
+
+import asyncio
+import subprocess
+import signal
+from pathlib import Path
+from typing import Dict, Optional
+import psutil
+
+from .config import HOSTED_MCPS_DIR
+
+
+class MCPHostManager:
+    """Manages running MCP server processes"""
+
+    def __init__(self):
+        self.running_mcps: Dict[str, subprocess.Popen] = {}
+        self.mcp_ports: Dict[str, int] = {}
+
+    async def start_mcp(self, mcp_id: str) -> dict:
+        """Start a hosted MCP server
+
+        Args:
+            mcp_id: The MCP server ID
+
+        Returns:
+            dict with status and connection info
+        """
+        mcp_path = HOSTED_MCPS_DIR / mcp_id / "server.py"
+
+        if not mcp_path.exists():
+            return {
+                "success": False,
+                "error": f"MCP {mcp_id} not found"
+            }
+
+        # Check if already running
+        if mcp_id in self.running_mcps:
+            proc = self.running_mcps[mcp_id]
+            if proc.poll() is None:  # Still running
+                return {
+                    "success": True,
+                    "status": "already_running",
+                    "mcp_id": mcp_id,
+                    "connection": "stdio"
+                }
+
+        try:
+            # Start the MCP server as a subprocess
+            proc = subprocess.Popen(
+                ["python", str(mcp_path)],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=str(mcp_path.parent)
+            )
+
+            self.running_mcps[mcp_id] = proc
+
+            return {
+                "success": True,
+                "status": "started",
+                "mcp_id": mcp_id,
+                "pid": proc.pid,
+                "connection": "stdio"
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    async def stop_mcp(self, mcp_id: str) -> dict:
+        """Stop a running MCP server
+
+        Args:
+            mcp_id: The MCP server ID
+
+        Returns:
+            dict with status
+        """
+        if mcp_id not in self.running_mcps:
+            return {
+                "success": False,
+                "error": "MCP not running"
+            }
+
+        proc = self.running_mcps[mcp_id]
+
+        try:
+            # Try graceful shutdown first
+            proc.terminate()
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                # Force kill if necessary
+                proc.kill()
+                proc.wait()
+
+            del self.running_mcps[mcp_id]
+
+            return {
+                "success": True,
+                "status": "stopped",
+                "mcp_id": mcp_id
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    def get_status(self, mcp_id: str) -> dict:
+        """Get status of an MCP server
+
+        Args:
+            mcp_id: The MCP server ID
+
+        Returns:
+            dict with status info
+        """
+        if mcp_id not in self.running_mcps:
+            return {
+                "running": False,
+                "mcp_id": mcp_id
+            }
+
+        proc = self.running_mcps[mcp_id]
+
+        if proc.poll() is not None:
+            # Process ended
+            del self.running_mcps[mcp_id]
+            return {
+                "running": False,
+                "mcp_id": mcp_id,
+                "exit_code": proc.returncode
+            }
+
+        return {
+            "running": True,
+            "mcp_id": mcp_id,
+            "pid": proc.pid
+        }
+
+    def list_all(self) -> list:
+        """List all hosted MCPs
+
+        Returns:
+            List of MCP info dicts
+        """
+        mcps = []
+
+        for mcp_dir in HOSTED_MCPS_DIR.iterdir():
+            if mcp_dir.is_dir():
+                mcp_id = mcp_dir.name
+                status = self.get_status(mcp_id)
+
+                mcps.append({
+                    "mcp_id": mcp_id,
+                    "path": str(mcp_dir),
+                    "running": status["running"]
+                })
+
+        return mcps
+
+    async def cleanup(self):
+        """Stop all running MCPs"""
+        for mcp_id in list(self.running_mcps.keys()):
+            await self.stop_mcp(mcp_id)
+
+
+# Global instance
+mcp_host = MCPHostManager()

src/mcp_registry.py

@@ -0,0 +1,167 @@
+"""MCP Registry - Track generated MCPs to avoid duplicates"""
+
+import json
+from pathlib import Path
+from typing import Optional, Dict, List
+from datetime import datetime
+import hashlib
+
+from .config import HOSTED_MCPS_DIR
+
+
+class MCPRegistry:
+    """Registry for tracking generated MCPs"""
+
+    def __init__(self):
+        self.registry_file = HOSTED_MCPS_DIR / "registry.json"
+        self.registry: Dict[str, dict] = {}
+        self._load()
+
+    def _load(self):
+        """Load registry from disk"""
+        if self.registry_file.exists():
+            try:
+                with open(self.registry_file, 'r') as f:
+                    self.registry = json.load(f)
+            except Exception:
+                self.registry = {}
+        else:
+            self.registry = {}
+
+    def _save(self):
+        """Save registry to disk"""
+        self.registry_file.parent.mkdir(exist_ok=True)
+        with open(self.registry_file, 'w') as f:
+            json.dump(self.registry, indent=2, fp=f)
+
+    def _url_hash(self, api_url: str) -> str:
+        """Generate a consistent hash for an API URL"""
+        # Normalize URL (remove trailing slashes, lowercase)
+        normalized = api_url.lower().rstrip('/')
+        return hashlib.md5(normalized.encode()).hexdigest()
+
+    def find_by_url(self, api_url: str) -> Optional[dict]:
+        """Find an existing MCP for a given API URL
+
+        Args:
+            api_url: The API URL to search for
+
+        Returns:
+            MCP info dict if found, None otherwise
+        """
+        url_hash = self._url_hash(api_url)
+
+        if url_hash in self.registry:
+            mcp_info = self.registry[url_hash]
+
+            # Check if the MCP directory still exists
+            mcp_path = HOSTED_MCPS_DIR / mcp_info['mcp_id']
+            if mcp_path.exists():
+                return mcp_info
+            else:
+                # Clean up stale entry
+                del self.registry[url_hash]
+                self._save()
+
+        return None
+
+    def register(self, api_url: str, mcp_id: str, api_name: str, metadata: dict = None) -> dict:
+        """Register a new MCP
+
+        Args:
+            api_url: The API URL
+            mcp_id: The generated MCP ID
+            api_name: The API name
+            metadata: Optional metadata dict
+
+        Returns:
+            The registered MCP info
+        """
+        url_hash = self._url_hash(api_url)
+
+        mcp_info = {
+            'mcp_id': mcp_id,
+            'api_url': api_url,
+            'api_name': api_name,
+            'created_at': datetime.now().isoformat(),
+            'last_used': datetime.now().isoformat(),
+            'metadata': metadata or {}
+        }
+
+        self.registry[url_hash] = mcp_info
+        self._save()
+
+        return mcp_info
+
+    def update_last_used(self, api_url: str):
+        """Update the last_used timestamp for an MCP
+
+        Args:
+            api_url: The API URL
+        """
+        url_hash = self._url_hash(api_url)
+
+        if url_hash in self.registry:
+            self.registry[url_hash]['last_used'] = datetime.now().isoformat()
+            self._save()
+
+    def list_all(self) -> List[dict]:
+        """List all registered MCPs
+
+        Returns:
+            List of MCP info dicts
+        """
+        # Filter out MCPs whose directories no longer exist
+        valid_mcps = []
+
+        for url_hash, mcp_info in list(self.registry.items()):
+            mcp_path = HOSTED_MCPS_DIR / mcp_info['mcp_id']
+            if mcp_path.exists():
+                valid_mcps.append(mcp_info)
+            else:
+                # Clean up stale entry
+                del self.registry[url_hash]
+
+        if len(valid_mcps) != len(self.registry):
+            self._save()
+
+        # Sort by last_used, most recent first
+        valid_mcps.sort(key=lambda x: x['last_used'], reverse=True)
+
+        return valid_mcps
+
+    def delete(self, api_url: str) -> bool:
+        """Delete an MCP from registry
+
+        Args:
+            api_url: The API URL
+
+        Returns:
+            True if deleted, False if not found
+        """
+        url_hash = self._url_hash(api_url)
+
+        if url_hash in self.registry:
+            del self.registry[url_hash]
+            self._save()
+            return True
+
+        return False
+
+    def get_stats(self) -> dict:
+        """Get registry statistics
+
+        Returns:
+            Stats dict
+        """
+        mcps = self.list_all()
+
+        return {
+            'total_mcps': len(mcps),
+            'oldest': mcps[-1]['created_at'] if mcps else None,
+            'newest': mcps[0]['created_at'] if mcps else None,
+        }
+
+
+# Global registry instance
+mcp_registry = MCPRegistry()

src/templates/mcp_server_template.py.jinja

@@ -0,0 +1,82 @@
+"""
+Generated MCP Server for {{ api_name }}
+Auto-generated by MCP Generator
+
+API URL: {{ api_url }}
+Generated: {{ timestamp }}
+"""
+
+import asyncio
+import json
+from typing import Any
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+import httpx
+
+# Initialize MCP server
+app = Server("{{ server_name }}")
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available 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 %}
+    ]
+
+@app.call_tool()
+async def call_tool(name: str, arguments: Any) -> list[TextContent]:
+    """Handle 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 }}"""
+    async with httpx.AsyncClient() 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 }}
+        )
+        {% endif %}
+
+        return [TextContent(
+            type="text",
+            text=json.dumps(response.json(), indent=2)
+        )]
+
+{% endfor %}
+
+async def main():
+    """Run the MCP server"""
+    async with stdio_server() as (read_stream, write_stream):
+        await app.run(
+            read_stream,
+            write_stream,
+            app.create_initialization_options()
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/templates/readme_template.md.jinja

@@ -0,0 +1,70 @@
+# {{ api_name }} MCP Server
+
+Auto-generated MCP server for {{ api_name }} API.
+
+**Generated:** {{ timestamp }}
+**API URL:** {{ api_url }}
+
+## 🚀 Quick Start
+
+### Option 1: Use Hosted Version (Easiest!)
+
+This MCP is already running! Just add to your Claude Desktop config:
+
+```json
+{
+  "mcpServers": {
+    "{{ server_name }}": {
+      "url": "{{ hosted_url }}"
+    }
+  }
+}
+```
+
+### Option 2: Run Locally
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the server
+python server.py
+```
+
+## 🛠️ Available Tools
+
+{% for tool in tools %}
+### `{{ tool.name }}`
+
+{{ tool.description }}
+
+**Parameters:**
+{% for param, schema in tool.parameters.items() %}
+- `{{ param }}` ({{ schema.type }}): {{ schema.description }}
+{% endfor %}
+
+**Example:**
+```json
+{
+  {% for param in tool.required %}
+  "{{ param }}": "example_value"{% if not loop.last %},{% endif %}
+  {% endfor %}
+}
+```
+
+---
+{% endfor %}
+
+## 📝 API Information
+
+- **Base URL:** {{ api_url }}
+- **Authentication:** {{ auth_type }}
+- **Rate Limits:** {{ rate_limits }}
+
+## 🤖 Generated by
+
+[MCP Generator](https://huggingface.co/spaces/MCP-1st-Birthday/mcp-generator) - Turn any API into an MCP server in seconds!
+
+---
+
+**Note:** This is an auto-generated MCP server. You may need to customize authentication and error handling for production use.