redshift fixes

Author: marcosfede

README.md

@@ -1210,67 +1210,7 @@ docker run --rm -i \
 Amazon Redshift is a fast, scalable data warehouse that makes it simple and cost-effective to analyze all your data using standard SQL and your existing business intelligence tools.
 
 > [!Note] 
-> Redshift requires a custom tools configuration file because it doesn't support all PostgreSQL features used in the prebuilt tools (e.g., `array_agg` with `ORDER BY`).
-
-### Creating the Redshift Configuration
-
-First, create a file named `redshift.yaml` with the following content:
-
-```yaml
-tools:
-  - name: list_tables
-    description: Lists detailed schema information for tables. If table_names are provided, shows details for those specific tables; otherwise shows all tables in user schemas.
-    parameters:
-      type: object
-      properties:
-        table_names:
-          type: string
-          description: Optional comma-separated list of table names. If empty, details for all tables in user-accessible schemas will be listed.
-      required:
-        - table_names
-    steps:
-      - type: sql
-        query: |
-          SELECT 
-            c.table_schema AS schema_name,
-            c.table_name,
-            c.column_name,
-            c.ordinal_position AS column_position,
-            c.data_type,
-            c.is_nullable,
-            c.column_default
-          FROM 
-            information_schema.columns c
-          WHERE 
-            c.table_schema NOT IN ('pg_catalog', 'information_schema', 'pg_temp_1', 'pg_toast', 'pg_internal')
-            AND (
-              :table_names IS NULL 
-              OR :table_names = ''
-              OR (',' || :table_names || ',') LIKE ('%,' || c.table_name || ',%')
-            )
-          ORDER BY 
-            c.table_schema,
-            c.table_name,
-            c.ordinal_position;
-        params:
-          - name: table_names
-            type: string
-            description: Optional comma-separated list of table names
-
-  - name: execute_sql
-    description: Execute arbitrary SQL queries against the Redshift database.
-    parameters:
-      type: object
-      properties:
-        sql:
-          type: string
-          description: The SQL query to execute.
-      required:
-        - sql
-    steps:
-      - type: sql
-        query: "{{sql}}"
-```
+> Redshift uses a custom Docker image with pre-configured tools optimized for Redshift's SQL dialect.
 
 ### Docker Command
 
@@ -1280,18 +1220,14 @@ REDSHIFT_DATABASE=mydb \
 REDSHIFT_USER=awsuser \
 REDSHIFT_PASSWORD=your-password \
 REDSHIFT_PORT=5439 \
-REDSHIFT_TOOLS_FILE=/path/to/redshift.yaml \
 docker run --rm -i \
   --name mcp-redshift \
-  -e POSTGRES_HOST=$REDSHIFT_HOST \
-  -e POSTGRES_DATABASE=$REDSHIFT_DATABASE \
-  -e POSTGRES_USER=$REDSHIFT_USER \
-  -e POSTGRES_PASSWORD=$REDSHIFT_PASSWORD \
-  -e POSTGRES_PORT=$REDSHIFT_PORT \
-  -v $REDSHIFT_TOOLS_FILE:/config/redshift.yaml \
-  us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest \
-  --tools-file /config/redshift.yaml \
-  --stdio
+  -e REDSHIFT_HOST \
+  -e REDSHIFT_DATABASE \
+  -e REDSHIFT_USER \
+  -e REDSHIFT_PASSWORD \
+  -e REDSHIFT_PORT \
+  us-central1-docker.pkg.dev/database-toolbox/toolbox/redshift:latest
 ```
 
 ### MCP Client Configuration
@@ -1301,37 +1237,33 @@ docker run --rm -i \
   "command": "docker",
   "args": [
     "run", "--rm", "-i",
-    "-e", "POSTGRES_HOST",
-    "-e", "POSTGRES_DATABASE",
-    "-e", "POSTGRES_USER",
-    "-e", "POSTGRES_PASSWORD",
-    "-e", "POSTGRES_PORT",
-    "-v", "${REDSHIFT_TOOLS_FILE}:/config/redshift.yaml",
-    "us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest",
-    "--tools-file", "/config/redshift.yaml",
-    "--stdio"
+    "-e", "REDSHIFT_HOST",
+    "-e", "REDSHIFT_DATABASE",
+    "-e", "REDSHIFT_USER",
+    "-e", "REDSHIFT_PASSWORD",
+    "-e", "REDSHIFT_PORT",
+    "us-central1-docker.pkg.dev/database-toolbox/toolbox/redshift:latest"
   ],
   "env": {
-    "POSTGRES_HOST": "your-cluster.redshift.amazonaws.com",
-    "POSTGRES_DATABASE": "mydb",
-    "POSTGRES_USER": "awsuser",
-    "POSTGRES_PASSWORD": "your-password",
-    "POSTGRES_PORT": "5439",
-    "REDSHIFT_TOOLS_FILE": "/path/to/redshift.yaml"
+    "REDSHIFT_HOST": "your-cluster.redshift.amazonaws.com",
+    "REDSHIFT_DATABASE": "mydb",
+    "REDSHIFT_USER": "awsuser",
+    "REDSHIFT_PASSWORD": "your-password",
+    "REDSHIFT_PORT": "5439"
   }
 }
 ```
 
 ### Environment Variables
 
-| Variable              | Required | Description                      | Default | Example                               |
-| --------------------- | -------- | -------------------------------- | ------- | ------------------------------------- |
-| `POSTGRES_HOST`       | Yes      | Redshift cluster endpoint        | -       | `your-cluster.redshift.amazonaws.com` |
-| `POSTGRES_PORT`       | No       | Redshift port                    | `5439`  | `5439`                                |
-| `POSTGRES_DATABASE`   | Yes      | Database name                    | -       | `mydb`                                |
-| `POSTGRES_USER`       | Yes      | Username                         | -       | `awsuser`                             |
-| `POSTGRES_PASSWORD`   | Yes      | Password                         | -       | `your-password`                       |
-| `REDSHIFT_TOOLS_FILE` | Yes      | Path to tools configuration YAML | -       | `/path/to/redshift.yaml`              |
+| Variable            | Required | Description               | Default  | Example                               |
+| ------------------- | -------- | ------------------------- | -------- | ------------------------------------- |
+| `REDSHIFT_HOST`     | Yes      | Redshift cluster endpoint | -        | `your-cluster.redshift.amazonaws.com` |
+| `REDSHIFT_PORT`     | No       | Redshift port             | `5439`   | `5439`                                |
+| `REDSHIFT_DATABASE` | Yes      | Database name             | -        | `mydb`                                |
+| `REDSHIFT_USER`     | Yes      | Username                  | -        | `awsuser`                             |
+| `REDSHIFT_PASSWORD` | Yes      | Password                  | -        | `your-password`                       |
+| `REDSHIFT_SSL_MODE` | No       | SSL mode                  | `prefer` | `disable`, `require`, `verify-full`   |
 
 
 ## Snowflake

images/redshift/entrypoint.sh

@@ -30,6 +30,40 @@ check_redshift_tools_file() {
     fi
 }
 
+# Function to map REDSHIFT_* environment variables to POSTGRES_*
+# The toolbox uses POSTGRES_* internally for the postgres kind source
+map_redshift_to_postgres_vars() {
+    # Map REDSHIFT_HOST to POSTGRES_HOST if POSTGRES_HOST is not set
+    if [[ -n "${REDSHIFT_HOST:-}" && -z "${POSTGRES_HOST:-}" ]]; then
+        export POSTGRES_HOST="${REDSHIFT_HOST}"
+    fi
+    
+    # Map REDSHIFT_PORT to POSTGRES_PORT if POSTGRES_PORT is not set
+    if [[ -n "${REDSHIFT_PORT:-}" && -z "${POSTGRES_PORT:-}" ]]; then
+        export POSTGRES_PORT="${REDSHIFT_PORT}"
+    fi
+    
+    # Map REDSHIFT_DATABASE to POSTGRES_DATABASE if POSTGRES_DATABASE is not set
+    if [[ -n "${REDSHIFT_DATABASE:-}" && -z "${POSTGRES_DATABASE:-}" ]]; then
+        export POSTGRES_DATABASE="${REDSHIFT_DATABASE}"
+    fi
+    
+    # Map REDSHIFT_USER to POSTGRES_USER if POSTGRES_USER is not set
+    if [[ -n "${REDSHIFT_USER:-}" && -z "${POSTGRES_USER:-}" ]]; then
+        export POSTGRES_USER="${REDSHIFT_USER}"
+    fi
+    
+    # Map REDSHIFT_PASSWORD to POSTGRES_PASSWORD if POSTGRES_PASSWORD is not set
+    if [[ -n "${REDSHIFT_PASSWORD:-}" && -z "${POSTGRES_PASSWORD:-}" ]]; then
+        export POSTGRES_PASSWORD="${REDSHIFT_PASSWORD}"
+    fi
+    
+    # Map REDSHIFT_SSL_MODE to POSTGRES_SSL_MODE if POSTGRES_SSL_MODE is not set
+    if [[ -n "${REDSHIFT_SSL_MODE:-}" && -z "${POSTGRES_SSL_MODE:-}" ]]; then
+        export POSTGRES_SSL_MODE="${REDSHIFT_SSL_MODE}"
+    fi
+}
+
 # Main execution
 main() {
     log "Starting Redshift custom toolbox entrypoint"
@@ -40,9 +74,12 @@ main() {
     # Check if Redshift tools file exists
     check_redshift_tools_file
 
-    # Execute the original toolbox with Redshift tools file and passed arguments
-    log "Executing Redshift toolbox with arguments: $*"
-    exec "$ORIGINAL_ENTRYPOINT" "--tools-file" "$REDSHIFT_TOOLS_FILE" "$@"
+    # Map REDSHIFT_* environment variables to POSTGRES_*
+    map_redshift_to_postgres_vars
+    
+    # Execute the original toolbox with Redshift tools file, --stdio, and any additional arguments
+    log "Executing Redshift toolbox with arguments: --tools-file $REDSHIFT_TOOLS_FILE --stdio $*"
+    exec "$ORIGINAL_ENTRYPOINT" "--tools-file" "$REDSHIFT_TOOLS_FILE" "--stdio" "$@"
 }
 
 # Handle edge cases

tests/redshift/example_usage.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Example usage of the Redshift MCP Server
+Demonstrates how to use the list_tables and execute_sql tools
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+# Configuration - update these with your Redshift credentials
+REDSHIFT_HOST = "redshift-prod-cluster.cd6o5qin6bij.us-west-2.redshift.amazonaws.com"
+REDSHIFT_DATABASE = "redshift"
+REDSHIFT_USER = "redshift_readonly"
+REDSHIFT_PASSWORD = "your-password"
+REDSHIFT_PORT = "5439"
+DOCKER_IMAGE = "redshift-toolbox:latest"  # Or use the built image
+
+
+def send_mcp_request(process, method, params, request_id):
+    """Send an MCP JSON-RPC request"""
+    request = {
+        "jsonrpc": "2.0",
+        "method": method,
+        "params": params,
+        "id": request_id,
+    }
+    process.stdin.write(json.dumps(request) + "\n")
+    process.stdin.flush()
+
+
+def read_mcp_response(process):
+    """Read an MCP JSON-RPC response"""
+    line = process.stdout.readline()
+    if not line:
+        return None
+    return json.loads(line)
+
+
+def list_tables_example(process, table_names=""):
+    """Example: List tables"""
+    print(f"\n📋 Listing tables (table_names='{table_names}')...")
+    send_mcp_request(
+        process,
+        "tools/call",
+        {
+            "name": "list_tables",
+            "arguments": {"table_names": table_names},
+        },
+        request_id=100,
+    )
+    
+    response = read_mcp_response(process)
+    if response and "result" in response:
+        content = response["result"].get("content", [])
+        print(f"✓ Found {len(content)} columns")
+        
+        # Parse and show first few columns
+        if content:
+            print("\nFirst few columns:")
+            for i, item in enumerate(content[:5]):
+                if item.get("type") == "text":
+                    col_info = json.loads(item["text"])
+                    print(f"  - {col_info['schema_name']}.{col_info['table_name']}.{col_info['column_name']} ({col_info['data_type']})")
+        return True
+    else:
+        print(f"✗ Error: {response.get('error', 'Unknown error')}")
+        return False
+
+
+def execute_sql_example(process, sql_query):
+    """Example: Execute SQL query"""
+    print(f"\n🔍 Executing SQL: {sql_query[:50]}...")
+    send_mcp_request(
+        process,
+        "tools/call",
+        {
+            "name": "execute_sql",
+            "arguments": {"sql": sql_query},
+        },
+        request_id=200,
+    )
+    
+    response = read_mcp_response(process)
+    if response and "result" in response:
+        content = response["result"].get("content", [])
+        print("✓ Query executed successfully")
+        
+        # Show results
+        for item in content:
+            if item.get("type") == "text":
+                print(f"  {item['text']}")
+        return True
+    else:
+        print(f"✗ Error: {response.get('error', 'Unknown error')}")
+        return False
+
+
+def main():
+    print("🚀 Redshift MCP Server Examples\n")
+    
+    # Start the Docker container
+    cmd = [
+        "docker", "run", "--rm", "-i",
+        "-e", "POSTGRES_HOST",
+        "-e", "POSTGRES_DATABASE",
+        "-e", "POSTGRES_USER",
+        "-e", "POSTGRES_PASSWORD",
+        "-e", "POSTGRES_PORT",
+        DOCKER_IMAGE,
+        "--stdio",
+    ]
+    
+    env = {
+        "POSTGRES_HOST": REDSHIFT_HOST,
+        "POSTGRES_DATABASE": REDSHIFT_DATABASE,
+        "POSTGRES_USER": REDSHIFT_USER,
+        "POSTGRES_PASSWORD": REDSHIFT_PASSWORD,
+        "POSTGRES_PORT": REDSHIFT_PORT,
+    }
+    
+    process = subprocess.Popen(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        env=env,
+    )
+    
+    try:
+        # Initialize
+        print("1. Initializing MCP connection...")
+        send_mcp_request(
+            process,
+            "initialize",
+            {
+                "protocolVersion": "1.0.0",
+                "capabilities": {},
+                "clientInfo": {"name": "example-client", "version": "1.0.0"},
+            },
+            request_id=1,
+        )
+        
+        init_response = read_mcp_response(process)
+        if init_response and "result" in init_response:
+            print("✓ Connected to Redshift MCP Server")
+        else:
+            print(f"✗ Failed to initialize: {init_response}")
+            return
+        
+        # Example 1: List all tables
+        list_tables_example(process, table_names="")
+        
+        # Example 2: List specific tables
+        list_tables_example(process, table_names="stripe_subscriptions,teams_aggregate")
+        
+        # Example 3: Simple query
+        execute_sql_example(process, "SELECT current_date AS today;")
+        
+        # Example 4: Count rows
+        execute_sql_example(process, "SELECT COUNT(*) as total FROM analytics.stripe_subscriptions;")
+        
+        # Example 5: Query with filters
+        execute_sql_example(
+            process,
+            "SELECT org_id, subscription_status, plan_slug FROM analytics.teams_aggregate LIMIT 5;"
+        )
+        
+        print("\n✅ Examples completed!")
+        
+    except Exception as e:
+        print(f"✗ Error: {e}")
+        stderr_output = process.stderr.read() if process.stderr else ""
+        if stderr_output:
+            print(f"✗ Stderr: {stderr_output}")
+    finally:
+        process.terminate()
+        process.wait(timeout=5)
+
+
+if __name__ == "__main__":
+    main()
+