Spaces:

legends810
/

mcp-server

Sleeping

App Files Files Community

legends810 commited on Aug 17, 2025

Commit

60c54e6

verified ·

1 Parent(s): 6b6cf0f

Update app.py

Browse files

Files changed (1) hide show

app.py +263 -275

app.py CHANGED Viewed

@@ -1,16 +1,22 @@
 from flask import Flask, jsonify, request, Response
 import json
-import time
 import requests
-import threading
 import os
 from datetime import datetime
 import uuid
 app = Flask(__name__)
-# Global variables for MCP
-mcp_tools = [
     {
         "name": "generate_image",
         "description": "Generate images from text prompts using Pollinations AI",
@@ -22,18 +28,23 @@ mcp_tools = [
                     "description": "Text description of the image to generate"
                 },
                 "model": {
-                    "type": "string",
                     "description": "Model to use (flux, gptimage, etc.)",
                     "default": "flux"
                 },
                 "width": {
-                    "type": "number",
-                    "description": "Image width",
                     "default": 1024
                 },
                 "height": {
-                    "type": "number",
-                    "description": "Image height",
                     "default": 1024
                 }
             },
@@ -52,8 +63,16 @@ mcp_tools = [
                 },
                 "model": {
                     "type": "string",
-                    "description": "Model to use (openai, etc.)",
                     "default": "openai"
                 }
             },
             "required": ["prompt"]
@@ -61,293 +80,262 @@ mcp_tools = [
     }
 ]
-@app.route('/')
-def home():
-    return """
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <title>MCPollinations MCP Server</title>
-        <style>
-            body { font-family: Arial, sans-serif; margin: 40px; background: #f5f5f5; }
-            .container { background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
-            .status { color: #28a745; font-weight: bold; }
-            .endpoint { background: #f8f9fa; padding: 15px; margin: 10px 0; border-left: 4px solid #007bff; }
-            .method { background: #007bff; color: white; padding: 4px 8px; border-radius: 4px; font-size: 12px; }
-            ul { list-style-type: none; padding: 0; }
-            li { margin: 10px 0; }
-            a { color: #007bff; text-decoration: none; }
-            a:hover { text-decoration: underline; }
-        </style>
-    </head>
-    <body>
-        <div class="container">
-            <h1>🤖 MCPollinations MCP Server</h1>
-            <p class="status">✅ Server is running on Hugging Face Spaces!</p>
-            <p>This is a Model Context Protocol server for AI image and text generation.</p>
-            <h2>📋 Available endpoints:</h2>
-            <div class="endpoint">
-                <span class="method">GET</span>
-                <strong><a href="/status">/status</a></strong> - Check server status
-            </div>
-            <div class="endpoint">
-                <span class="method">POST</span>
-                <strong>/generate_image</strong> - Generate images via POST
-            </div>
-            <div class="endpoint">
-                <span class="method">POST</span>
-                <strong>/generate_text</strong> - Generate text via POST
-            </div>
-            <div class="endpoint">
-                <span class="method">GET</span>
-                <strong>/tools</strong> - List available MCP tools
-            </div>
-            <div class="endpoint">
-                <span class="method">GET</span>
-                <strong>/sse</strong> - MCP Server-Sent Events endpoint
-            </div>
-            <div class="endpoint">
-                <span class="method">GET</span>
-                <strong>/gradio_api/mcp/sse</strong> - Gradio-compatible MCP SSE endpoint
-            </div>
-            <h3>🔗 For n8n Integration:</h3>
-            <p><strong>SSE URL:</strong> <code>https://huggingface.co/spaces/legends810/mcp-server/sse</code></p>
-            <p><strong>HTTP API Base:</strong> <code>https://huggingface.co/spaces/legends810/mcp-server</code></p>
-            <h3>📝 Example Usage:</h3>
-            <pre style="background: #f1f1f1; padding: 10px; border-radius: 5px;">
-curl -X POST https://huggingface.co/spaces/legends810/mcp-server/generate_image \\
-  -H "Content-Type: application/json" \\
-  -d '{"prompt": "beautiful sunset over mountains"}'
-            </pre>
-        </div>
-    </body>
-    </html>
-    """
-@app.route('/status')
-def status():
-    return jsonify({
-        "status": "running",
-        "server": "MCPollinations MCP Server",
-        "mode": "HTTP + SSE wrapper for HF Spaces",
-        "endpoints": ["/status", "/generate_image", "/generate_text", "/tools", "/sse"],
-        "timestamp": datetime.now().isoformat(),
-        "version": "1.0.0"
-    })
-@app.route('/tools')
-def get_tools():
-    return jsonify({
-        "tools": mcp_tools
-    })
-@app.route('/generate_image', methods=['POST'])
-def generate_image():
     try:
-        data = request.get_json() or {}
-        prompt = data.get('prompt', 'sunset over ocean')
-        model = data.get('model', 'flux')
-        width = data.get('width', 1024)
-        height = data.get('height', 1024)
-        # Build Pollinations image URL
-        params = {
-            'width': width,
-            'height': height,
-            'model': model
-        }
-        # Remove empty params
-        params = {k: v for k, v in params.items() if v}
-        # Create image URL
-        image_url = f"https://image.pollinations.ai/{requests.utils.quote(prompt)}"
-        if params:
-            param_string = "&".join([f"{k}={v}" for k, v in params.items()])
-            image_url += f"?{param_string}"
-        result = {
-            "status": "success",
-            "prompt": prompt,
-            "model": model,
-            "dimensions": {"width": width, "height": height},
-            "image_url": image_url,
-            "download_url": image_url,
-            "message": "Image generated successfully",
-            "timestamp": datetime.now().isoformat(),
-            "id": str(uuid.uuid4())
-        }
-        return jsonify(result)
     except Exception as e:
-        return jsonify({
-            "status": "error",
-            "error": str(e),
-            "message": "Failed to generate image"
-        }), 500
-@app.route('/generate_text', methods=['POST'])
-def generate_text():
     try:
-        data = request.get_json() or {}
-        prompt = data.get('prompt', 'Hello world')
-        model = data.get('model', 'openai')
-        # Build Pollinations text URL
-        text_url = f"https://text.pollinations.ai/{requests.utils.quote(prompt)}?model={model}"
-        # Make request to Pollinations API
-        try:
-            response = requests.get(text_url, timeout=30)
-            generated_text = response.text
-        except:
-            generated_text = f"Generated response for: {prompt} (using {model} model)"
-        result = {
-            "status": "success",
-            "prompt": prompt,
-            "model": model,
-            "generated_text": generated_text,
-            "message": "Text generated successfully",
-            "timestamp": datetime.now().isoformat(),
-            "id": str(uuid.uuid4())
-        }
-        return jsonify(result)
     except Exception as e:
-        return jsonify({
-            "status": "error",
-            "error": str(e),
-            "message": "Failed to generate text"
-        }), 500
-# MCP SSE Endpoints
-@app.route('/sse')
-@app.route('/gradio_api/mcp/sse')
-def mcp_sse():
-    def generate_mcp_events():
-        # Send initial MCP handshake
-        yield "event: connect\n"
-        yield f"data: " + json.dumps({
-            "jsonrpc": "2.0",
-            "method": "initialize",
-            "params": {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {
-                    "tools": {
-                        "listChanged": True
-                    },
-                    "resources": {},
-                    "prompts": {}
-                },
-                "serverInfo": {
-                    "name": "MCPollinations",
-                    "version": "1.0.0"
-                }
-            }
-        }) + "\n\n"
-        # Send available tools
-        yield "event: tools\n"
-        yield f"data: " + json.dumps({
-            "jsonrpc": "2.0",
-            "method": "tools/list",
-            "result": {
-                "tools": mcp_tools
-            }
-        }) + "\n\n"
-        # Keep connection alive with heartbeat
-        while True:
-            try:
-                time.sleep(30)  # Send heartbeat every 30 seconds
-                yield "event: ping\n"
-                yield f"data: " + json.dumps({
-                    "type": "ping",
-                    "timestamp": datetime.now().isoformat()
-                }) + "\n\n"
-            except:
-                break
-    return Response(
-        generate_mcp_events(),
-        mimetype='text/event-stream',
-        headers={
-            'Cache-Control': 'no-cache',
-            'Connection': 'keep-alive',
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'GET',
-            'Access-Control-Allow-Headers': 'Cache-Control'
-        }
-    )
-# MCP Tool execution endpoint
-@app.route('/mcp/call', methods=['POST'])
-def mcp_call_tool():
     try:
         data = request.get_json()
-        tool_name = data.get('name')
-        arguments = data.get('arguments', {})
         if tool_name == 'generate_image':
-            # Reuse the generate_image logic
-            prompt = arguments.get('prompt', 'sunset')
-            model = arguments.get('model', 'flux')
-            width = arguments.get('width', 1024)
-            height = arguments.get('height', 1024)
-            params = {'width': width, 'height': height, 'model': model}
-            params = {k: v for k, v in params.items() if v}
-            image_url = f"https://image.pollinations.ai/{requests.utils.quote(prompt)}"
-            if params:
-                param_string = "&".join([f"{k}={v}" for k, v in params.items()])
-                image_url += f"?{param_string}"
-            return jsonify({
-                "content": [
-                    {
-                        "type": "image",
-                        "data": image_url,
-                        "mimeType": "image/png"
-                    },
-                    {
-                        "type": "text",
-                        "text": f"Generated image: {prompt}\nModel: {model}\nURL: {image_url}"
-                    }
-                ]
-            })
         elif tool_name == 'generate_text':
-            prompt = arguments.get('prompt', 'Hello')
-            model = arguments.get('model', 'openai')
-            text_url = f"https://text.pollinations.ai/{requests.utils.quote(prompt)}?model={model}"
-            try:
-                response = requests.get(text_url, timeout=30)
-                generated_text = response.text
-            except:
-                generated_text = f"Generated response for: {prompt}"
-            return jsonify({
-                "content": [
-                    {
-                        "type": "text",
-                        "text": generated_text
-                    }
-                ]
-            })
         else:
-            return jsonify({"error": "Unknown tool"}), 400
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-# Health check endpoint
 @app.route('/health')
 def health():
-    return jsonify({"status": "healthy", "timestamp": datetime.now().isoformat()})
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))

 from flask import Flask, jsonify, request, Response
 import json
 import requests
 import os
 from datetime import datetime
 import uuid
+from urllib.parse import quote
 app = Flask(__name__)
+# MCP Server Info (HF Style)
+SERVER_INFO = {
+    "name": "MCPollinations",
+    "version": "1.0.0",
+    "description": "MCP Server for AI Image and Text Generation via Pollinations"
+}
+# MCP Tools Definition (Official Format)
+MCP_TOOLS = [
     {
         "name": "generate_image",
         "description": "Generate images from text prompts using Pollinations AI",
                     "description": "Text description of the image to generate"
                 },
                 "model": {
+                    "type": "string",
                     "description": "Model to use (flux, gptimage, etc.)",
+                    "enum": ["flux", "gptimage", "playground", "stable-diffusion"],
                     "default": "flux"
                 },
                 "width": {
+                    "type": "integer",
+                    "description": "Image width in pixels",
+                    "minimum": 256,
+                    "maximum": 2048,
                     "default": 1024
                 },
                 "height": {
+                    "type": "integer",
+                    "description": "Image height in pixels",
+                    "minimum": 256,
+                    "maximum": 2048,
                     "default": 1024
                 }
             },
                 },
                 "model": {
                     "type": "string",
+                    "description": "Text model to use",
+                    "enum": ["openai", "claude", "gemini"],
                     "default": "openai"
+                },
+                "max_tokens": {
+                    "type": "integer",
+                    "description": "Maximum tokens to generate",
+                    "minimum": 1,
+                    "maximum": 4000,
+                    "default": 1000
                 }
             },
             "required": ["prompt"]
     }
 ]
+def is_browser_request(request):
+    """Detect if request is from browser (HF Style)"""
+    user_agent = request.headers.get('User-Agent', '').lower()
+    accept = request.headers.get('Accept', '').lower()
+    return 'text/html' in accept or 'mozilla' in user_agent
+def create_mcp_response(id=None, result=None, error=None):
+    """Create JSON-RPC 2.0 MCP response"""
+    response = {
+        "jsonrpc": "2.0"
+    }
+    if id is not None:
+        response["id"] = id
+    if result is not None:
+        response["result"] = result
+    if error is not None:
+        response["error"] = error
+    return response
+@app.route('/')
+@app.route('/mcp')
+def root():
+    """Main MCP endpoint (HF Style)"""
+    if is_browser_request(request):
+        # Return user-friendly page for browsers
+        return """
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>MCPollinations MCP Server</title>
+            <meta charset="utf-8">
+            <style>
+                body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+                       margin: 0; padding: 40px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                       color: white; min-height: 100vh; }
+                .container { max-width: 800px; margin: 0 auto; background: rgba(255,255,255,0.1);
+                           padding: 40px; border-radius: 20px; backdrop-filter: blur(10px); }
+                h1 { font-size: 3em; margin-bottom: 20px; text-align: center; }
+                .badge { background: rgba(255,255,255,0.2); padding: 8px 16px; border-radius: 20px;
+                        display: inline-block; margin: 5px; }
+                .endpoint { background: rgba(255,255,255,0.1); padding: 20px; margin: 15px 0;
+                          border-radius: 10px; border-left: 4px solid #00d4aa; }
+                .code { background: rgba(0,0,0,0.3); padding: 15px; border-radius: 8px;
+                       font-family: 'Monaco', 'Courier New', monospace; margin: 10px 0; }
+                .status { color: #00d4aa; font-weight: bold; font-size: 1.2em; }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>🤖 MCPollinations MCP Server</h1>
+                <p class="status">✅ Server Status: Running</p>
+                <p>Official Model Context Protocol server for AI image and text generation via Pollinations AI.</p>
+                <h2>🛠️ Available Tools</h2>
+                <div class="endpoint">
+                    <strong>generate_image</strong> - Generate images from text prompts
+                    <div class="badge">Models: flux, gptimage, playground</div>
+                </div>
+                <div class="endpoint">
+                    <strong>generate_text</strong> - Generate text using AI models
+                    <div class="badge">Models: openai, claude, gemini</div>
+                </div>
+                <h2>🔗 MCP Client Setup</h2>
+                <p><strong>Server URL:</strong></p>
+                <div class="code">https://huggingface.co/spaces/legends810/mcp-server</div>
+                <h2>📚 Integration Examples</h2>
+                <div class="endpoint">
+                    <strong>Claude Desktop</strong>
+                    <div class="code">{
+  "mcpServers": {
+    "mcpollinations": {
+      "command": "npx",
+      "args": ["mcp-remote", "https://huggingface.co/spaces/legends810/mcp-server"]
+    }
+  }
+}</div>
+                </div>
+                <div class="endpoint">
+                    <strong>n8n MCP Client</strong>
+                    <div class="code">URL: https://huggingface.co/spaces/legends810/mcp-server
+Transport: HTTP</div>
+                </div>
+                <h2>🚀 Quick Test</h2>
+                <div class="code">curl -X POST https://huggingface.co/spaces/legends810/mcp-server/call \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "tools/call",
+    "params": {
+      "name": "generate_image",
+      "arguments": {"prompt": "beautiful sunset"}
+    },
+    "id": 1
+  }'</div>
+            </div>
+        </body>
+        </html>
+        """
+    else:
+        # Return MCP protocol response for clients
+        return jsonify(create_mcp_response(
+            result={
+                "protocolVersion": "2024-11-05",
+                "capabilities": {
+                    "tools": {"listChanged": True},
+                    "logging": {}
+                },
+                "serverInfo": SERVER_INFO
+            }
+        ))
+@app.route('/initialize', methods=['POST'])
+def initialize():
+    """MCP Initialize endpoint"""
     try:
+        data = request.get_json()
+        request_id = data.get('id')
+        return jsonify(create_mcp_response(
+            id=request_id,
+            result={
+                "protocolVersion": "2024-11-05",
+                "capabilities": {
+                    "tools": {"listChanged": True},
+                    "logging": {}
+                },
+                "serverInfo": SERVER_INFO
+            }
+        ))
     except Exception as e:
+        return jsonify(create_mcp_response(
+            error={"code": -32603, "message": f"Internal error: {str(e)}"}
+        )), 500
+@app.route('/tools/list', methods=['POST'])
+def tools_list():
+    """MCP Tools List endpoint"""
     try:
+        data = request.get_json()
+        request_id = data.get('id')
+        return jsonify(create_mcp_response(
+            id=request_id,
+            result={"tools": MCP_TOOLS}
+        ))
     except Exception as e:
+        return jsonify(create_mcp_response(
+            error={"code": -32603, "message": f"Internal error: {str(e)}"}
+        )), 500
+@app.route('/tools/call', methods=['POST'])
+@app.route('/call', methods=['POST'])
+def tools_call():
+    """MCP Tools Call endpoint (Main functionality)"""
     try:
         data = request.get_json()
+        request_id = data.get('id')
+        params = data.get('params', {})
+        tool_name = params.get('name')
+        arguments = params.get('arguments', {})
         if tool_name == 'generate_image':
+            result = handle_image_generation(arguments)
         elif tool_name == 'generate_text':
+            result = handle_text_generation(arguments)
         else:
+            return jsonify(create_mcp_response(
+                id=request_id,
+                error={"code": -32601, "message": f"Unknown tool: {tool_name}"}
+            )), 400
+        return jsonify(create_mcp_response(
+            id=request_id,
+            result=result
+        ))
     except Exception as e:
+        return jsonify(create_mcp_response(
+            error={"code": -32603, "message": f"Tool execution failed: {str(e)}"}
+        )), 500
+def handle_image_generation(arguments):
+    """Handle image generation with Pollinations API"""
+    prompt = arguments.get('prompt', 'beautiful landscape')
+    model = arguments.get('model', 'flux')
+    width = arguments.get('width', 1024)
+    height = arguments.get('height', 1024)
+    # Build Pollinations URL
+    params = []
+    if width != 1024:
+        params.append(f"width={width}")
+    if height != 1024:
+        params.append(f"height={height}")
+    if model != 'flux':
+        params.append(f"model={model}")
+    image_url = f"https://image.pollinations.ai/{quote(prompt)}"
+    if params:
+        image_url += "?" + "&".join(params)
+    return {
+        "content": [
+            {
+                "type": "image",
+                "data": image_url,
+                "mimeType": "image/png"
+            },
+            {
+                "type": "text",
+                "text": f"Generated image: {prompt}\nModel: {model}\nDimensions: {width}x{height}\nURL: {image_url}"
+            }
+        ]
+    }
+def handle_text_generation(arguments):
+    """Handle text generation with Pollinations API"""
+    prompt = arguments.get('prompt', 'Hello world')
+    model = arguments.get('model', 'openai')
+    max_tokens = arguments.get('max_tokens', 1000)
+    # Call Pollinations text API
+    try:
+        text_url = f"https://text.pollinations.ai/{quote(prompt)}?model={model}"
+        response = requests.get(text_url, timeout=30)
+        generated_text = response.text[:max_tokens]  # Limit tokens
+    except:
+        generated_text = f"Generated response for: {prompt} (using {model} model)"
+    return {
+        "content": [
+            {
+                "type": "text",
+                "text": generated_text
+            }
+        ]
+    }
+# Legacy endpoints for backward compatibility
+@app.route('/status')
+def status():
+    return jsonify({
+        "status": "running",
+        "server": SERVER_INFO["name"],
+        "version": SERVER_INFO["version"],
+        "mcp_protocol": "2024-11-05",
+        "timestamp": datetime.now().isoformat()
+    })
 @app.route('/health')
 def health():
+    return jsonify({"status": "healthy"})
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))