API Gateway MCP

import { Server } from '@modelcontextprotocol/sdk/server'
import { APIGatewayTool } from './tools/APIGatewayTool'

const server = new Server({
  name: 'api-gateway-mcp',
  version: '1.0.0'
})

// Register API gateway tool
server.tool(new APIGatewayTool({
  allowedApis: process.env.ALLOWED_APIS?.split(','),
  rateLimit: parseInt(process.env.RATE_LIMIT || '100'),
  authRequired: process.env.AUTH_REQUIRED === 'true'
}))

server.listen({
  port: 3000,
  host: 'localhost'
})

import { Tool } from '@modelcontextprotocol/sdk/server'
import axios from 'axios'

interface APIGatewayConfig {
  allowedApis: string[]
  rateLimit: number
  authRequired: boolean
}

export class APIGatewayTool extends Tool {
  private config: APIGatewayConfig
  private requestCounts: Map<string, number> = new Map()
  
  constructor(config: APIGatewayConfig) {
    super({
      name: 'api_gateway',
      description: 'Secure access to external APIs with rate limiting and authentication',
      inputSchema: {
        type: 'object',
        properties: {
          api: { type: 'string', enum: config.allowedApis },
          endpoint: { type: 'string' },
          method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'] },
          headers: { type: 'object' },
          body: { type: 'object' },
          authToken: { type: 'string' }
        },
        required: ['api', 'endpoint', 'method']
      }
    })
    this.config = config
  }

  async execute(input: any) {
    // Validate API access
    if (!this.config.allowedApis.includes(input.api)) {
      throw new Error(`API ${input.api} not allowed`)
    }

    // Check rate limiting
    if (!this.checkRateLimit(input.api)) {
      throw new Error('Rate limit exceeded')
    }

    // Validate authentication if required
    if (this.config.authRequired && !input.authToken) {
      throw new Error('Authentication token required')
    }

    // Make API request
    try {
      const response = await this.makeRequest(input)
      this.incrementRequestCount(input.api)
      return response
    } catch (error) {
      throw new Error(`API request failed: ${error.message}`)
    }
  }

  private checkRateLimit(api: string): boolean {
    const count = this.requestCounts.get(api) || 0
    return count < this.config.rateLimit
  }

  private incrementRequestCount(api: string) {
    const count = this.requestCounts.get(api) || 0
    this.requestCounts.set(api, count + 1)
  }

  private async makeRequest(input: any) {
    const config = {
      method: input.method,
      url: `${input.api}${input.endpoint}`,
      headers: {
        'Content-Type': 'application/json',
        ...input.headers
      },
      data: input.body
    }

    if (input.authToken) {
      config.headers['Authorization'] = `Bearer ${input.authToken}`
    }

    const response = await axios(config)
    return {
      status: response.status,
      data: response.data,
      headers: response.headers
    }
  }
}

import { Client } from '@modelcontextprotocol/sdk/client'

const client = new Client({
  serverUrl: 'ws://localhost:3000'
})

// Example: Call external API through MCP
const result = await client.tools.api_gateway.execute({
  api: 'https://api.openweathermap.org',
  endpoint: '/data/2.5/weather',
  method: 'GET',
  headers: { 'Accept': 'application/json' },
  body: { q: 'London,UK', appid: 'your-api-key' }
})

console.log('Weather data:', result.data)

// Example: Authenticated API call
const authResult = await client.tools.api_gateway.execute({
  api: 'https://api.github.com',
  endpoint: '/user',
  method: 'GET',
  headers: { 'Accept': 'application/vnd.github.v3+json' },
  authToken: 'your-github-token'
})

console.log('GitHub user:', authResult.data)