@naganpm/snowflake-mcp-server 1.0.0

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@naganpm/snowflake-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for Snowflake database integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "snowflake-mcp-server": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "watch": "tsc --watch",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "snowflake",
+    "database",
+    "express",
+    "typescript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.1",
+    "express": "^4.18.2",
+    "snowflake-sdk": "^1.11.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.11.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/postman_collection.json

@@ -0,0 +1,148 @@
+{
+  "info": {
+    "name": "Snowflake MCP Server",
+    "description": "API collection for Snowflake MCP Server",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "Health Check",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/health",
+          "host": ["{{base_url}}"],
+          "path": ["health"]
+        }
+      }
+    },
+    {
+      "name": "Connection Status",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/status",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "status"]
+        }
+      }
+    },
+    {
+      "name": "Execute Query",
+      "request": {
+        "method": "POST",
+        "header": [
+          {
+            "key": "Content-Type",
+            "value": "application/json"
+          }
+        ],
+        "body": {
+          "mode": "raw",
+          "raw": "{\n  \"query\": \"SELECT CURRENT_DATE(), CURRENT_USER(), CURRENT_ROLE()\"\n}"
+        },
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/query",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "query"]
+        }
+      }
+    },
+    {
+      "name": "List Databases",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/databases",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "databases"]
+        }
+      }
+    },
+    {
+      "name": "List Schemas",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/schemas?database=YOUR_DATABASE",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "schemas"],
+          "query": [
+            {
+              "key": "database",
+              "value": "YOUR_DATABASE"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "name": "List Tables",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/tables?database=YOUR_DATABASE&schema=PUBLIC",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "tables"],
+          "query": [
+            {
+              "key": "database",
+              "value": "YOUR_DATABASE"
+            },
+            {
+              "key": "schema",
+              "value": "PUBLIC"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "name": "Describe Table",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/tables/YOUR_TABLE/describe",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "tables", "YOUR_TABLE", "describe"]
+        }
+      }
+    },
+    {
+      "name": "List Warehouses",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/warehouses",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "warehouses"]
+        }
+      }
+    },
+    {
+      "name": "Get Current Session",
+      "request": {
+        "method": "GET",
+        "header": [],
+        "url": {
+          "raw": "{{base_url}}/api/snowflake/session",
+          "host": ["{{base_url}}"],
+          "path": ["api", "snowflake", "session"]
+        }
+      }
+    }
+  ],
+  "variable": [
+    {
+      "key": "base_url",
+      "value": "http://localhost:3000"
+    }
+  ]
+}

package/src/index.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import express, { Express, Request, Response } from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { SnowflakeService } from './services/snowflake.service';
+import { errorHandler } from './middleware/error.middleware';
+import { snowflakeRoutes } from './routes/snowflake.routes';
+
+dotenv.config();
+
+const app: Express = express();
+const port = process.env.PORT || 3000;
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Health check
+app.get('/health', (req: Request, res: Response) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+// Snowflake routes
+app.use('/api/snowflake', snowflakeRoutes);
+
+// Error handler
+app.use(errorHandler);
+
+// Initialize Snowflake connection
+const snowflakeService = SnowflakeService.getInstance();
+
+app.listen(port, () => {
+  console.log(`🚀 Snowflake MCP Server running on port ${port}`);
+  console.log(`📊 Health check: http://localhost:${port}/health`);
+});
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\n🛑 Shutting down gracefully...');
+  await snowflakeService.disconnect();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.log('\n🛑 Shutting down gracefully...');
+  await snowflakeService.disconnect();
+  process.exit(0);
+});
+
+export default app;

package/src/mcp-server.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { SnowflakeService } from './services/snowflake.service';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const snowflakeService = SnowflakeService.getInstance();
+
+const server = new Server(
+  {
+    name: 'snowflake-mcp-server',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'execute_query',
+        description: 'Execute a SQL query on Snowflake database',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'SQL query to execute' },
+            binds: { type: 'array', description: 'Optional bind parameters' },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'list_databases',
+        description: 'List all databases',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'list_schemas',
+        description: 'List schemas',
+        inputSchema: {
+          type: 'object',
+          properties: { database: { type: 'string' } },
+        },
+      },
+      {
+        name: 'list_tables',
+        description: 'List tables',
+        inputSchema: {
+          type: 'object',
+          properties: { database: { type: 'string' }, schema: { type: 'string' } },
+        },
+      },
+      {
+        name: 'describe_table',
+        description: 'Describe table structure',
+        inputSchema: {
+          type: 'object',
+          properties: { tableName: { type: 'string' } },
+          required: ['tableName'],
+        },
+      },
+      {
+        name: 'list_warehouses',
+        description: 'List warehouses',
+        inputSchema: { type: 'object', properties: {} },
+      },
+      {
+        name: 'get_session_info',
+        description: 'Get session info',
+        inputSchema: { type: 'object', properties: {} },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: args } = request.params;
+    let result;
+
+    switch (name) {
+      case 'execute_query':
+        result = await snowflakeService.executeQuery((args?.query as string) || '', args?.binds as any);
+        break;
+      case 'list_databases':
+        result = await snowflakeService.listDatabases();
+        break;
+      case 'list_schemas':
+        result = await snowflakeService.listSchemas(args?.database as string);
+        break;
+      case 'list_tables':
+        result = await snowflakeService.listTables(args?.database as string, args?.schema as string);
+        break;
+      case 'describe_table':
+        result = await snowflakeService.describeTable((args?.tableName as string) || '');
+        break;
+      case 'list_warehouses':
+        result = await snowflakeService.listWarehouses();
+        break;
+      case 'get_session_info':
+        result = await snowflakeService.getCurrentSession();
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  } catch (error: any) {
+    return {
+      content: [{ type: 'text', text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Snowflake MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Failed to start MCP server:', error);
+  process.exit(1);
+});

package/src/middleware/error.middleware.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from 'express';
+
+export const errorHandler = (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  console.error('❌ Error:', err);
+
+  const statusCode = err.statusCode || 500;
+  const message = err.message || 'Internal Server Error';
+
+  res.status(statusCode).json({
+    success: false,
+    error: {
+      message,
+      code: err.code || 'INTERNAL_ERROR',
+      ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
+    },
+  });
+};

package/src/routes/snowflake.routes.ts

@@ -0,0 +1,123 @@
+import { Router, Request, Response, NextFunction } from 'express';
+import { SnowflakeService } from '../services/snowflake.service';
+
+const router = Router();
+const snowflakeService = SnowflakeService.getInstance();
+
+// Execute query
+router.post('/query', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { query, binds } = req.body;
+
+    if (!query) {
+      return res.status(400).json({ error: 'Query is required' });
+    }
+
+    const result = await snowflakeService.executeQuery(query, binds);
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// List databases
+router.get('/databases', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = await snowflakeService.listDatabases();
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// List schemas
+router.get('/schemas', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { database } = req.query;
+    const result = await snowflakeService.listSchemas(database as string);
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// List tables
+router.get('/tables', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { database, schema } = req.query;
+    const result = await snowflakeService.listTables(
+      database as string,
+      schema as string
+    );
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// Describe table
+router.get('/tables/:tableName/describe', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { tableName } = req.params;
+    const result = await snowflakeService.describeTable(tableName);
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// List warehouses
+router.get('/warehouses', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = await snowflakeService.listWarehouses();
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// Get current session
+router.get('/session', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = await snowflakeService.getCurrentSession();
+    res.json({
+      success: true,
+      data: result,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+// Connection status
+router.get('/status', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const isConnected = snowflakeService.isConnected();
+    res.json({
+      success: true,
+      connected: isConnected,
+    });
+  } catch (error: any) {
+    next(error);
+  }
+});
+
+export { router as snowflakeRoutes };

package/src/services/snowflake.service.ts

@@ -0,0 +1,149 @@
+import snowflake from 'snowflake-sdk';
+
+export interface SnowflakeConfig {
+  account: string;
+  username: string;
+  password: string;
+  warehouse?: string;
+  database?: string;
+  schema?: string;
+}
+
+export interface QueryResult {
+  columns: string[];
+  rows: any[];
+  rowCount: number;
+  executionTime: number;
+}
+
+export class SnowflakeService {
+  private static instance: SnowflakeService;
+  private connection: snowflake.Connection | null = null;
+  private config: SnowflakeConfig;
+
+  private constructor() {
+    this.config = {
+      account: process.env.SNOWFLAKE_ACCOUNT || '',
+      username: process.env.SNOWFLAKE_USERNAME || '',
+      password: process.env.SNOWFLAKE_PASSWORD || '',
+      warehouse: process.env.SNOWFLAKE_WAREHOUSE,
+      database: process.env.SNOWFLAKE_DATABASE,
+      schema: process.env.SNOWFLAKE_SCHEMA,
+    };
+  }
+
+  public static getInstance(): SnowflakeService {
+    if (!SnowflakeService.instance) {
+      SnowflakeService.instance = new SnowflakeService();
+    }
+    return SnowflakeService.instance;
+  }
+
+  private async connect(): Promise<snowflake.Connection> {
+    if (this.connection) {
+      return this.connection;
+    }
+
+    return new Promise((resolve, reject) => {
+      const connectionOptions: any = {
+        account: this.config.account,
+        username: this.config.username,
+        password: this.config.password,
+      };
+
+      if (this.config.warehouse) connectionOptions.warehouse = this.config.warehouse;
+      if (this.config.database) connectionOptions.database = this.config.database;
+      if (this.config.schema) connectionOptions.schema = this.config.schema;
+
+      this.connection = snowflake.createConnection(connectionOptions);
+
+      this.connection.connect((err, conn) => {
+        if (err) {
+          console.error('❌ Failed to connect to Snowflake:', err.message);
+          reject(err);
+        } else {
+          console.log('✅ Successfully connected to Snowflake');
+          resolve(conn);
+        }
+      });
+    });
+  }
+
+  public async executeQuery(sqlText: string, binds?: any[]): Promise<QueryResult> {
+    const startTime = Date.now();
+    const conn = await this.connect();
+
+    return new Promise((resolve, reject) => {
+      conn.execute({
+        sqlText,
+        binds,
+        complete: (err, stmt, rows) => {
+          const executionTime = Date.now() - startTime;
+
+          if (err) {
+            reject(err);
+          } else {
+            const columns = stmt.getColumns().map(col => col.getName());
+            resolve({
+              columns,
+              rows: rows || [],
+              rowCount: rows?.length || 0,
+              executionTime,
+            });
+          }
+        },
+      });
+    });
+  }
+
+  public async listDatabases(): Promise<QueryResult> {
+    return this.executeQuery('SHOW DATABASES');
+  }
+
+  public async listSchemas(database?: string): Promise<QueryResult> {
+    if (database) {
+      return this.executeQuery(`SHOW SCHEMAS IN DATABASE ${database}`);
+    }
+    return this.executeQuery('SHOW SCHEMAS');
+  }
+
+  public async listTables(database?: string, schema?: string): Promise<QueryResult> {
+    if (database && schema) {
+      return this.executeQuery(`SHOW TABLES IN ${database}.${schema}`);
+    }
+    return this.executeQuery('SHOW TABLES');
+  }
+
+  public async describeTable(tableName: string): Promise<QueryResult> {
+    return this.executeQuery(`DESCRIBE TABLE ${tableName}`);
+  }
+
+  public async listWarehouses(): Promise<QueryResult> {
+    return this.executeQuery('SHOW WAREHOUSES');
+  }
+
+  public async getCurrentSession(): Promise<QueryResult> {
+    return this.executeQuery('SELECT CURRENT_USER(), CURRENT_ROLE(), CURRENT_DATABASE(), CURRENT_SCHEMA(), CURRENT_WAREHOUSE()');
+  }
+
+  public async disconnect(): Promise<void> {
+    if (this.connection) {
+      return new Promise((resolve, reject) => {
+        this.connection!.destroy((err) => {
+          if (err) {
+            console.error('❌ Error disconnecting from Snowflake:', err.message);
+            reject(err);
+          } else {
+            console.log('✅ Disconnected from Snowflake');
+            this.connection = null;
+            resolve();
+          }
+        });
+      });
+    }
+  }
+
+  public isConnected(): boolean {
+    return this.connection !== null;
+  }
+}