Expose Any MCP Server as a Web API

┌─────────────────┐                    ┌───────────────────────────────────┐
│   Internet      │                    │          Your Machine             │
│   Users         │                    │                                   │
│                 │    ngrok tunnel    │  ┌─────────────┐  stdio pipes     │
│     Mobile      │◄──────────────────►│  │ Express.js  │◄────────────────► │
│     Browser     │                    │  │ HTTP API    │  ┌─────────────┐ │
│     API Calls   │                    │  │ (Port 3000) │  │ MCP Server  │ │
│                 │                    │  └─────────────┘  │ (Your Code) │ │
└─────────────────┘                    │                   └─────────────┘ │
                                       └───────────────────────────────────┘

HTTP Requests                          MCP Protocol Messages      MCP Tools
(GET/POST)            ←────────→       (stdin/stdout)       ←────► (Unchanged)

START MCP_SERVER_PROCESS
ON HTTP_REQUEST:
  - Convert HTTP to MCP message format
  - Send to MCP process via stdin  
  - Wait for response from stdout
  - Convert MCP response to HTTP
  - Return to client

const express = require('express');
const { spawn } = require('child_process');

const app = express();
app.use(express.json());

let mcp = null;
let requestId = 1;
const pending = new Map();
let buffer = '';
// Start MCP server
function startMCP() {
  // Replace with your MCP server command
  mcp = spawn('uvx', ['your-mcp-package']);
  
  mcp.stdout.on('data', (data) => {
    buffer += data.toString();
    
    // Process complete JSON messages
    const lines = buffer.split('\n');
    buffer = lines.pop(); // Keep incomplete line
    
    lines.forEach(line => {
      if (line.trim()) {
        try {
          const response = JSON.parse(line);
          
          // TODO: Adjust this to match your MCP server's response format
          // This assumes responses have an 'id' field - modify as needed
          const requestId = response.id; // Change this line for your format
          const request = pending.get(requestId);
          
          if (request) {
            pending.delete(requestId);
            request.resolve(response);
          }
        } catch (error) {
          console.log('MCP output:', line);
        }
      }
    });
  });
  mcp.stderr.on('data', (data) => {
    console.error('MCP error:', data.toString());
  });
  mcp.on('close', (code) => {
    console.log(`MCP server closed with code ${code}`);
    // Auto-restart in production
    setTimeout(startMCP, 1000);
  });
}
// Send request to MCP
async function callMCP(tool, arguments) {
  if (!mcp) throw new Error('MCP server not running');
  
  const id = requestId++;
  
  // TODO: Replace this with YOUR MCP server's exact message format
  // This is just an example - check your MCP server's documentation
  const request = {
    id,
    method: "your_method_name",  // Replace with actual method
    params: {
      tool: tool,
      args: arguments
      // Adjust structure to match your server
    }
  };
  return new Promise((resolve, reject) => {
    pending.set(id, { resolve, reject });
    mcp.stdin.write(JSON.stringify(request) + '\n');
    
    // Timeout after 30 seconds
    setTimeout(() => {
      if (pending.has(id)) {
        pending.delete(id);
        reject(new Error('Request timeout'));
      }
    }, 30000);
  });
}
// API Endpoints
app.post('/api/:tool', async (req, res) => {
  try {
    const result = await callMCP(req.params.tool, req.body);
    
    // TODO: Adjust error checking based on your MCP server's response format
    // This is just an example - modify based on how your server indicates errors
    if (result.error) {
      return res.status(400).json({ error: result.error });
    }
    
    // Return the full response - adjust as needed for your format
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});
app.get('/health', (req, res) => {
  res.json({ 
    status: mcp ? 'running' : 'stopped',
    uptime: process.uptime()
  });
});
// Test interface
app.get('/', (req, res) => {
  res.send(`
    <h2>MCP API Test</h2>
    <form onsubmit="test(event)">
      <input name="tool" placeholder="Tool name" required><br><br>
      <textarea name="args" placeholder='{"key": "value"}'></textarea><br><br>
      <button>Execute</button>
    </form>
    <pre id="output"></pre>
    
    <script>
      async function test(e) {
        e.preventDefault();
        const form = new FormData(e.target);
        const tool = form.get('tool');
        const args = JSON.parse(form.get('args') || '{}');
        
        try {
          const res = await fetch('/api/' + tool, {
            method: 'POST',
            headers: {'Content-Type': 'application/json'},
            body: JSON.stringify(args)
          });
          
          const result = await res.json();
          document.getElementById('output').textContent = 
            JSON.stringify(result, null, 2);
        } catch (error) {
          document.getElementById('output').textContent = 'Error: ' + error.message;
        }
      }
    </script>
  `);
});
// Graceful shutdown
process.on('SIGINT', () => {
  if (mcp) mcp.kill();
  process.exit(0);
});
// Start everything
startMCP();
app.listen(3000, () => {
  console.log('API running on http://localhost:3000');
  console.log('Test interface available at the root URL');
});

{
  "name": "mcp-api-wrapper",
  "dependencies": {
    "express": "^4.18.2"
  }
}

# 1. Install dependencies
npm install

# 2. Update the spawn command in server.js to match your MCP server:
# spawn('node', ['your-server.js'])
# spawn('python', ['server.py']) 
# spawn('uvx', ['your-package'])

# 3. Start the API
node server.js

# 4. Make it public (new terminal)
npx ngrok http 3000