Data Connector MCP

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

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

// Register data connector tools
server.tool(new DataConnectorTool({
  databaseUrl: process.env.DATABASE_URL,
  apiKeys: process.env.API_KEYS?.split(','),
  allowedOperations: ['SELECT', 'READ']
}))

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

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

interface DataConnectorConfig {
  databaseUrl: string
  apiKeys: string[]
  allowedOperations: string[]
}

export class DataConnectorTool extends Tool {
  private config: DataConnectorConfig
  
  constructor(config: DataConnectorConfig) {
    super({
      name: 'data_connector',
      description: 'Connect to external data sources and retrieve information',
      inputSchema: {
        type: 'object',
        properties: {
          source: { type: 'string', enum: ['database', 'api', 'file'] },
          operation: { type: 'string' },
          query: { type: 'string' },
          parameters: { type: 'object' }
        },
        required: ['source', 'operation', 'query']
      }
    })
    this.config = config
  }

  async execute(input: any) {
    // Validate operation permissions
    if (!this.config.allowedOperations.includes(input.operation)) {
      throw new Error(`Operation ${input.operation} not allowed`)
    }

    // Execute based on source type
    switch (input.source) {
      case 'database':
        return await this.queryDatabase(input.query, input.parameters)
      case 'api':
        return await this.callApi(input.query, input.parameters)
      case 'file':
        return await this.readFile(input.query)
      default:
        throw new Error(`Unknown source: ${input.source}`)
    }
  }

  private async queryDatabase(query: string, params: any) {
    // Database query implementation with parameterized queries
    // and SQL injection prevention
  }

  private async callApi(endpoint: string, params: any) {
    // API call implementation with authentication and rate limiting
  }

  private async readFile(path: string) {
    // File reading implementation with path validation
  }
}

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

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

// Example: Query database through MCP
const result = await client.tools.data_connector.execute({
  source: 'database',
  operation: 'SELECT',
  query: 'SELECT * FROM users WHERE status = ?',
  parameters: { status: 'active' }
})

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

// Example: Call external API through MCP
const apiResult = await client.tools.data_connector.execute({
  source: 'api',
  operation: 'GET',
  query: '/api/weather/current',
  parameters: { city: 'New York' }
})

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