Snowflake Developer MCP Server 🚀

A powerful Model Context Protocol (MCP) server that provides comprehensive Snowflake database operations, Cortex AI services, and data management tools for AI assistants like Claude.

🌟 Features

• 🔧 DDL Operations: Create and manage databases, schemas, tables, and other database objects

• 📊 DML Operations: Insert, update, delete, and query data with full SQL support

• ⚙️ Snowflake Operations: Manage warehouses, grants, roles, and show database objects

• 🔒 Secure Authentication: Support for passwords and Programmatic Access Tokens (PAT)

• 🎯 Simple Connection Pattern: Per-operation connections for reliability and simplicity

🚀 Quick Start

Prerequisites

• Python 3.11+

• UV package manager (install from https://github.com/astral-sh/uv)

• Node.js and npm (for MCP inspector)

• Snowflake account with appropriate permissions

• Snowflake credentials (account identifier, username, password/PAT)

Installation

1. Clone the repository

   git clone https://github.com/mcp-tg/snowflake-developer.git
   cd snowflake-developer

2. Set up environment

   # Copy environment template
   cp .env.example .env
   
   # Edit .env with your Snowflake credentials
   # Required: SNOWFLAKE_ACCOUNT, SNOWFLAKE_USER, SNOWFLAKE_PAT (or SNOWFLAKE_PASSWORD)

3. Install UV (if not already installed)

   # On macOS/Linux
   curl -LsSf https://astral.sh/uv/install.sh | sh
   
   # On Windows
   powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

🧪 Testing with MCP Inspector

The easiest way to test your setup is using the MCP Inspector:

# Run the development inspector script
./dev-inspector.sh

This will:

• ✅ Create a virtual environment (if needed)

• ✅ Install all dependencies via UV

• ✅ Load your Snowflake credentials from .env

• ✅ Start the MCP Inspector web interface

• ✅ Open your browser to test tools interactively

Note: The script automatically handles UV package installation, so you don't need to manually install dependencies.

First Test: Verify Connection

1. In the Inspector, go to the Tools tab

2. Find test_snowflake_connection and click Run

3. You should see your account details and confirmation that the connection works

🔌 Integration with AI Assistants

Claude Desktop

Option 1: Direct from GitHub (no local clone needed)

{
  "mcpServers": {
    "snowflake-developer": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/mcp-tg/snowflake-developer.git",
        "main.py"
      ],
      "env": {
        "SNOWFLAKE_ACCOUNT": "your-account",
        "SNOWFLAKE_USER": "your-username",
        "SNOWFLAKE_PAT": "your-pat-token"
      }
    }
  }
}

Option 2: Local installation

{
  "mcpServers": {
    "snowflake-developer": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "/path/to/snowflake-developer",
        "python",
        "main.py"
      ],
      "env": {
        "SNOWFLAKE_ACCOUNT": "your-account",
        "SNOWFLAKE_USER": "your-username",
        "SNOWFLAKE_PAT": "your-pat-token"
      }
    }
  }
}

Setup Instructions:

1. Clone the repository: git clone https://github.com/mcp-tg/snowflake-developer.git

2. Create the Claude Desktop config file: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)

3. Add the configuration above, replacing /path/to/snowflake-developer with your actual path

4. Replace credential placeholders with your actual Snowflake credentials

5. Restart Claude Desktop

Cursor

Note: Cursor doesn't support environment variables in MCP configuration. You'll need to use the local installation option or set environment variables globally on your system.

Option 1: Direct from GitHub (requires global env vars)

{
  "mcpServers": {
    "snowflake-developer": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/mcp-tg/snowflake-developer.git",
        "main.py"
      ]
    }
  }
}

Requires setting SNOWFLAKE_ACCOUNT, SNOWFLAKE_USER, and SNOWFLAKE_PAT as system environment variables.

Option 2: Local installation (recommended for Cursor)

{
  "mcpServers": {
    "snowflake-developer": {
      "command": "uv",
      "args": ["run", "/path/to/snowflake-developer/main.py"]
    }
  }
}

Use a local .env file in the project directory with your credentials.

📚 Available Tools (22 Total)

🔧 DDL Tools (8 Tools)

Tools for managing database structure:

📊 DML Tools (6 Tools)

Tools for working with data:

⚙️ Snowflake Operations Tools (8 Tools)

Tools for Snowflake-specific operations:

🏗️ Architecture

The server uses a simple per-operation connection pattern:

• Each tool/resource call creates a fresh Snowflake connection

• Connections are automatically closed after each operation

• No connection pooling or persistence required

• Credentials are read from environment variables

🛡️ Security Best Practices

1. Use Programmatic Access Tokens (PAT) instead of passwords when possible

2. Never commit .env files to version control

3. Use least-privilege roles for your Snowflake user

4. Rotate credentials regularly

5. Consider using external secret management for production

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Troubleshooting

Connection Issues

• Verify your account identifier format

• Check that your user has appropriate permissions

• Ensure your PAT token hasn't expired

• Test network connectivity to Snowflake

Tool Errors

• Check the error message in the Inspector console

• Verify required parameters are provided

• Ensure database objects exist before referencing them

• Check SQL syntax for custom statements

🚀 FastMCP Framework

This MCP server is built using FastMCP, a modern Python framework that simplifies building Model Context Protocol servers. FastMCP provides:

Why FastMCP?

• 🎯 Simple API: Decorator-based tool and resource registration

• ⚡ High Performance: Async/await support with efficient message handling

• 🔧 Type Safety: Full TypeScript-style type hints and validation

• 📝 Auto Documentation: Automatic tool/resource documentation generation

• 🛡️ Error Handling: Built-in exception handling and response formatting

• 🔌 MCP Compliance: Full compatibility with MCP protocol specification

FastMCP vs Traditional MCP

# Traditional MCP server setup
class MyMCPServer:
    def __init__(self):
        self.tools = {}
    
    def register_tool(self, name, handler, schema):
        # Manual registration and validation
        pass

# FastMCP - Clean and Simple
from fastmcp import FastMCP

mcp = FastMCP("MyServer")

@mcp.tool()
def my_tool(param: str) -> str:
    """Tool with automatic type validation and documentation."""
    return f"Result: {param}"

@mcp.resource("my://resource/{id}")
async def my_resource(id: str, ctx: Context) -> dict:
    """Resource with built-in async support and context."""
    return {"data": f"Resource {id}"}

Key FastMCP Features Used

1. Decorator Registration: Tools are registered using simple decorators

2. Type Validation: Automatic parameter validation using Python type hints

3. Context Management: Built-in context for progress reporting and logging

4. Resource Patterns: URI template matching for dynamic resource endpoints

5. Error Handling: Automatic exception catching and standardized error responses

FastMCP Installation

# Install FastMCP
pip install fastmcp

# Or with UV (recommended)
uv add fastmcp

Learning FastMCP

• Official Docs: FastMCP Documentation

• Examples: Browse FastMCP example servers in the repository

• TypeScript MCP SDK: MCP TypeScript SDK

📚 Additional Resources

Snowflake Resources

• Snowflake Documentation

• Snowflake Python Connector

• Programmatic Access Tokens

MCP Protocol & Tools

• Model Context Protocol Specification

• MCP TypeScript SDK

• MCP Python SDK

• MCP Inspector Tool

Development Tools

• UV Package Manager

• FastMCP Framework

• Claude Desktop Configuration

• Cursor IDE Integration