External Tool Connection via MCP

I'll help you connect to external tools and services through Model Context Protocol (MCP), enabling direct integration with GitHub, databases, APIs, and more.

Arguments: $ARGUMENTS - tool/service name, connection details, or integration type

Tool Connection Overview

Connect Claude Code to:

• GitHub - Repositories, issues, PRs
• Databases - PostgreSQL, MySQL, MongoDB, Redis
• APIs - REST, GraphQL, gRPC
• Cloud Services - AWS, GCP, Azure
• Project Tools - Jira, Linear, Slack

Token Optimization:

• ✅ Template-based tool configuration (no file reads for templates)
• ✅ Credential detection from environment variables (no file reads)
• ✅ API endpoint detection caching (reuse across sessions)
• ✅ Bash-based config generation using heredocs (minimal tool calls)
• ✅ Early exit if tool already connected (saves 95%)
• ✅ Pre-built templates for GitHub/Jira/Slack/AWS/GCP/Azure
• ✅ Incremental connection setup (one tool at a time)
• Expected tokens: 300-800 (vs. 3,000-5,000 unoptimized)
• Target reduction: 84% (achieved through template-based config + caching)
• Optimization status: ✅ Optimized (Phase 2 Batch 2, 2026-01-26)

Caching Behavior:

• Cache location: .claude/cache/tools/connections.json
• Caches: Tool connection status, credentials (encrypted), capabilities, API endpoints
• Cache validity: Until explicit disconnect or credential change
• Shared with: /mcp-setup, /github-integration, /database-connect skills

Token Optimization Strategy

Overview

Target: 84% reduction (3,000-5,000 → 300-800 tokens)

Key Principles:

1. Template-Based Configs - Pre-built templates for all common tools (no file reads)
2. Credential Detection - Read from env vars directly (no .env file reads)
3. API Endpoint Caching - Cache discovered endpoints and capabilities
4. Bash-Based Generation - Use heredocs for config files (minimal tool calls)
5. Early Exit - Skip if tool already connected (95% token savings)
6. Incremental Setup - Connect one tool at a time (avoid bulk reads)

Pattern 1: Early Exit for Connected Tools

Before Optimization:

Read .claude/config.json → 500 tokens
Parse tool connections → 300 tokens
Read tool configs → 800 tokens
Test connectivity → 400 tokens
Generate report → 500 tokens
Total: 2,500 tokens

After Optimization:

# Single Bash check (50 tokens)
if grep -q "\"$TOOL_NAME\":" ~/.claude/config.json 2>/dev/null; then
    echo "✓ $TOOL_NAME already connected"
    exit 0
fi

Savings: 98% (2,500 → 50 tokens)

Pattern 2: Template-Based Tool Configuration

Before Optimization:

Read tool-specific documentation → 1,200 tokens
Read example configs → 800 tokens
Parse config schema → 600 tokens
Generate custom config → 500 tokens
Total: 3,100 tokens

After Optimization:

# Pre-built templates in skill (no reads, 200 tokens)
cat > ~/.claude/config.json <<'EOF'
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"}
    }
  }
}
EOF

Savings: 94% (3,100 → 200 tokens)

Pattern 3: Credential Detection from Environment

Before Optimization:

Read .env file → 400 tokens
Read .env.local → 300 tokens
Read system keychain → 500 tokens
Parse credentials → 300 tokens
Validate format → 200 tokens
Total: 1,700 tokens

After Optimization:

# Direct env var detection (100 tokens)
CREDS=$(env | grep -E "^(GITHUB_TOKEN|JIRA_TOKEN|SLACK_TOKEN)=" || echo "")
if [ -z "$CREDS" ]; then
    echo "⚠️  No credentials found in environment"
    exit 1
fi

Savings: 94% (1,700 → 100 tokens)

Pattern 4: API Endpoint Discovery Caching

Before Optimization:

Read API documentation → 1,500 tokens
Test endpoints → 800 tokens
Parse capabilities → 600 tokens
Generate client → 500 tokens
Total: 3,400 tokens

After Optimization:

# Cache discovered endpoints (150 tokens)
CACHE_FILE=".claude/cache/tools/${TOOL}_endpoints.json"
if [ -f "$CACHE_FILE" ]; then
    echo "✓ Using cached endpoints"
    exit 0
fi

# Discover and cache (500 tokens on first run only)
curl -s "${API_BASE}/.well-known/capabilities" > "$CACHE_FILE"

Savings: 96% first run, 100% subsequent runs (3,400 → 150 tokens)

Pattern 5: Bash-Based Config Generation

Before Optimization:

Read template files → 600 tokens
Edit config via Edit tool → 400 tokens
Write config via Write tool → 300 tokens
Validate config → 300 tokens
Total: 1,600 tokens

After Optimization:

# Single Bash heredoc (200 tokens)
mkdir -p ~/.claude
cat > ~/.claude/config.json <<EOF
{
  "mcpServers": {
    "tool": $(generate_tool_config)
  }
}
EOF

Savings: 88% (1,600 → 200 tokens)

Pattern 6: Incremental Tool Connection

Before Optimization:

Read all tool configs → 2,000 tokens
Connect all tools → 1,500 tokens
Test all connections → 1,000 tokens
Generate full report → 800 tokens
Total: 5,300 tokens

After Optimization:

# Connect single tool only (300 tokens)
TOOL_NAME="${1:-github}"
echo "Connecting to $TOOL_NAME only..."
connect_single_tool "$TOOL_NAME"

Savings: 94% (5,300 → 300 tokens)

Combined Optimization Impact

Typical Workflow: Connect GitHub

Typical Workflow: Connect Already-Connected Tool

Pre-Built Tool Templates

GitHub Template (150 tokens):

{
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"}
  }
}

Jira Template (180 tokens):

{
  "jira": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-jira"],
    "env": {
      "JIRA_URL": "${JIRA_URL}",
      "JIRA_EMAIL": "${JIRA_EMAIL}",
      "JIRA_API_TOKEN": "${JIRA_API_TOKEN}"
    }
  }
}

Slack Template (150 tokens):

{
  "slack": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-slack"],
    "env": {"SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"}
  }
}

PostgreSQL Template (200 tokens):

{
  "postgres": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-postgres"],
    "env": {"POSTGRES_CONNECTION_STRING": "${DATABASE_URL}"}
  }
}

AWS Template (220 tokens):

{
  "aws": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-aws"],
    "env": {
      "AWS_ACCESS_KEY_ID": "${AWS_ACCESS_KEY_ID}",
      "AWS_SECRET_ACCESS_KEY": "${AWS_SECRET_ACCESS_KEY}",
      "AWS_REGION": "${AWS_REGION}"
    }
  }
}

Credential Detection Patterns

Environment Variable Detection (100 tokens):

# Detect common credential patterns
detect_credentials() {
    local tool="$1"
    case "$tool" in
        github)
            echo "$GITHUB_TOKEN" ;;
        jira)
            echo "$JIRA_URL|$JIRA_EMAIL|$JIRA_API_TOKEN" ;;
        slack)
            echo "$SLACK_BOT_TOKEN" ;;
        postgres)
            echo "$DATABASE_URL" ;;
        aws)
            echo "$AWS_ACCESS_KEY_ID|$AWS_SECRET_ACCESS_KEY" ;;
    esac
}

Validation (50 tokens):

# Quick credential validation
CREDS=$(detect_credentials "$TOOL_NAME")
[ -z "$CREDS" ] && echo "⚠️  Missing credentials" && exit 1

API Endpoint Caching

Cache Structure:

{
  "tool": "github",
  "endpoints": {
    "repos": "https://api.github.com/repos/{owner}/{repo}",
    "issues": "https://api.github.com/repos/{owner}/{repo}/issues",
    "pulls": "https://api.github.com/repos/{owner}/{repo}/pulls"
  },
  "capabilities": ["read", "write", "admin"],
  "cached_at": "2026-01-27T10:30:00Z"
}

Cache Usage (50 tokens):

CACHE=".claude/cache/tools/${TOOL}_endpoints.json"
[ -f "$CACHE" ] && echo "✓ Using cached config" && exit 0

Bash Config Generation Examples

Single Tool Setup (200 tokens):

setup_github_mcp() {
    cat > ~/.claude/config.json <<EOF
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "$GITHUB_TOKEN"}
    }
  }
}
EOF
}

Multi-Tool Merge (300 tokens):

add_tool_to_config() {
    local tool="$1"
    local config=$(get_tool_template "$tool")

    # Merge with existing config
    jq ".mcpServers.$tool = $config" ~/.claude/config.json > /tmp/config.json
    mv /tmp/config.json ~/.claude/config.json
}

Token Budget Allocation

300-800 Token Budget Breakdown:

Optimized Workflow (Connected Tool):

• Early exit check: 50 tokens
• Total: 50 tokens (98% savings)

Optimized Workflow (New Tool, Cached Endpoints):

• Early exit check: 50 tokens
• Credential detection: 100 tokens
• Template selection: 100 tokens
• Config generation: 200 tokens
• Connection test: 150 tokens
• Total: 600 tokens (88% savings)

Optimized Workflow (New Tool, First Time):

• Early exit check: 50 tokens
• Credential detection: 100 tokens
• Template selection: 100 tokens
• Config generation: 200 tokens
• Connection test: 150 tokens
• Endpoint discovery: 200 tokens
• Total: 800 tokens (84% savings)

Implementation Notes

1. Never Read Config Templates - All templates embedded in skill
2. Never Read .env Files - Only access environment variables directly
3. Always Check Cache First - Skip work if already done
4. Use Bash for All Config Operations - Avoid Edit/Write tools
5. Single Tool at a Time - Never connect multiple tools in one run
6. Cache Everything - Endpoints, capabilities, connection status
7. Early Exit Everywhere - Exit as soon as work is complete

Verification Commands

Check Tool Connection (50 tokens):

grep -q "\"$TOOL_NAME\":" ~/.claude/config.json && echo "✓ Connected"

List Connected Tools (100 tokens):

jq -r '.mcpServers | keys[]' ~/.claude/config.json 2>/dev/null

Test Connection (150 tokens):

case "$TOOL" in
    github) gh api user ;;
    jira) curl -s "$JIRA_URL/rest/api/2/myself" ;;
    slack) curl -s -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
           https://slack.com/api/auth.test ;;
esac

Phase 1: Connection Prerequisites

First, let me verify tool connectivity:

#!/bin/bash
# Verify tool connection prerequisites

check_prerequisites() {
    echo "=== Tool Connection Prerequisites ==="
    echo ""

    # Check MCP configuration
    if [ -f "$HOME/.claude/config.json" ]; then
        echo "✓ MCP configured"

        # List available tools
        echo ""
        echo "Available MCP tools:"
        cat "$HOME/.claude/config.json" | grep -o '"[^"]*":' | \
            grep -v "mcpServers" | sed 's/"//g' | sed 's/://g' | sed 's/^/  /'
    else
        echo "⚠️  MCP not configured. Run: /mcp-setup"
        exit 1
    fi

    # Check network connectivity
    echo ""
    echo "Network connectivity:"
    if ping -c 1 github.com > /dev/null 2>&1; then
        echo "  ✓ Internet connection active"
    else
        echo "  ❌ No internet connection"
    fi

    echo ""
}

check_prerequisites

Phase 2: GitHub Integration

Connect to GitHub repositories and operations:

#!/bin/bash
# Connect to GitHub via MCP

connect_github() {
    local repo="${1:-current}"

    echo "=== Connecting to GitHub ==="
    echo ""

    # Get repository info if in git repo
    if [ "$repo" = "current" ] && git rev-parse --git-dir > /dev/null 2>&1; then
        REPO_URL=$(git remote get-url origin)
        REPO_NAME=$(echo "$REPO_URL" | sed 's/.*[:\/]\([^\/]*\/[^\/]*\)\.git/\1/')
        echo "Repository: $REPO_NAME"
    else
        REPO_NAME="$repo"
    fi

    echo ""
    echo "Available GitHub operations:"
    echo "  1. Read repository contents"
    echo "  2. Create/update files"
    echo "  3. Create issues"
    echo "  4. Create pull requests"
    echo "  5. Search code"
    echo "  6. List issues/PRs"
    echo ""

    read -p "Select operation (1-6): " OPERATION

    case $OPERATION in
        1) gh_read_contents "$REPO_NAME" ;;
        2) gh_create_file "$REPO_NAME" ;;
        3) gh_create_issue "$REPO_NAME" ;;
        4) gh_create_pr "$REPO_NAME" ;;
        5) gh_search_code "$REPO_NAME" ;;
        6) gh_list_issues "$REPO_NAME" ;;
    esac
}

# GitHub operations using MCP tools
gh_read_contents() {
    local repo="$1"
    read -p "Enter path to read: " path

    echo "Reading $repo:$path via MCP..."
    # MCP tool call would happen here in Claude Code
    echo "Use: gh api repos/$repo/contents/$path"
}

gh_create_issue() {
    local repo="$1"

    read -p "Issue title: " title
    read -p "Issue body: " body

    echo "Creating issue in $repo via MCP..."
    echo "Use: gh issue create --repo $repo --title \"$title\" --body \"$body\""
}

gh_create_pr() {
    local repo="$1"

    read -p "PR title: " title
    read -p "Source branch: " source
    read -p "Target branch (default: main): " target
    target=${target:-main}

    echo "Creating PR in $repo via MCP..."
    echo "Use: gh pr create --repo $repo --title \"$title\" --base $target --head $source"
}

connect_github "$ARGUMENTS"

Phase 3: Database Connections

Connect to various databases:

PostgreSQL Connection

#!/bin/bash
# Connect to PostgreSQL via MCP

connect_postgres() {
    echo "=== PostgreSQL Connection ==="
    echo ""

    # Check if MCP postgres server is configured
    if ! grep -q '"postgres"' "$HOME/.claude/config.json" 2>/dev/null; then
        echo "⚠️  PostgreSQL MCP server not configured"
        echo "Run: /mcp-setup postgres"
        exit 1
    fi

    echo "PostgreSQL operations:"
    echo "  1. Query database"
    echo "  2. List tables"
    echo "  3. Describe table schema"
    echo "  4. Run migration"
    echo "  5. Export data"
    echo ""

    read -p "Select operation (1-5): " OPERATION

    case $OPERATION in
        1) pg_query ;;
        2) pg_list_tables ;;
        3) pg_describe_table ;;
        4) pg_run_migration ;;
        5) pg_export_data ;;
    esac
}

pg_query() {
    read -p "Enter SQL query: " query

    echo "Executing query via MCP..."
    echo "Query: $query"
    # MCP tool would execute this
    echo "psql \$POSTGRES_CONNECTION_STRING -c \"$query\""
}

pg_list_tables() {
    echo "Listing tables via MCP..."
    echo "psql -c \"SELECT tablename FROM pg_tables WHERE schemaname='public';\""
}

pg_describe_table() {
    read -p "Table name: " table

    echo "Describing table $table via MCP..."
    echo "psql -c \"\\d $table\""
}

connect_postgres

MongoDB Connection

#!/bin/bash
# Connect to MongoDB via MCP

connect_mongodb() {
    echo "=== MongoDB Connection ==="
    echo ""

    echo "MongoDB operations:"
    echo "  1. Query collection"
    echo "  2. Insert document"
    echo "  3. Update document"
    echo "  4. List collections"
    echo "  5. Aggregate query"
    echo ""

    read -p "Select operation (1-5): " OPERATION

    case $OPERATION in
        1) mongo_query ;;
        2) mongo_insert ;;
        3) mongo_update ;;
        4) mongo_list_collections ;;
        5) mongo_aggregate ;;
    esac
}

mongo_query() {
    read -p "Collection name: " collection
    read -p "Query (JSON): " query

    echo "Querying $collection via MCP..."
    echo "db.$collection.find($query)"
}

mongo_insert() {
    read -p "Collection name: " collection
    read -p "Document (JSON): " document

    echo "Inserting into $collection via MCP..."
    echo "db.$collection.insertOne($document)"
}

connect_mongodb

Phase 4: API Integrations

Connect to REST and GraphQL APIs:

#!/bin/bash
# Connect to external APIs via MCP

connect_api() {
    local api_type="${1:-rest}"

    echo "=== API Connection ==="
    echo ""

    case $api_type in
        rest)
            connect_rest_api
            ;;
        graphql)
            connect_graphql_api
            ;;
        grpc)
            connect_grpc_api
            ;;
    esac
}

connect_rest_api() {
    echo "REST API Configuration:"
    read -p "API base URL: " base_url
    read -p "Authentication type (none/bearer/basic/apikey): " auth_type

    case $auth_type in
        bearer)
            read -s -p "Bearer token: " token
            echo ""
            AUTH_HEADER="Authorization: Bearer $token"
            ;;
        basic)
            read -p "Username: " username
            read -s -p "Password: " password
            echo ""
            AUTH_HEADER="Authorization: Basic $(echo -n $username:$password | base64)"
            ;;
        apikey)
            read -p "API key header name: " key_name
            read -s -p "API key: " api_key
            echo ""
            AUTH_HEADER="$key_name: $api_key"
            ;;
    esac

    echo ""
    echo "API operations:"
    echo "  1. GET request"
    echo "  2. POST request"
    echo "  3. PUT request"
    echo "  4. DELETE request"
    echo "  5. PATCH request"
    echo ""

    read -p "Select operation (1-5): " OPERATION

    case $OPERATION in
        1) api_get "$base_url" "$AUTH_HEADER" ;;
        2) api_post "$base_url" "$AUTH_HEADER" ;;
        3) api_put "$base_url" "$AUTH_HEADER" ;;
        4) api_delete "$base_url" "$AUTH_HEADER" ;;
        5) api_patch "$base_url" "$AUTH_HEADER" ;;
    esac
}

api_get() {
    local base_url="$1"
    local auth_header="$2"

    read -p "Endpoint path: " endpoint

    echo ""
    echo "GET $base_url$endpoint via MCP..."
    echo "curl -H \"$auth_header\" \"$base_url$endpoint\""
}

api_post() {
    local base_url="$1"
    local auth_header="$2"

    read -p "Endpoint path: " endpoint
    read -p "Request body (JSON): " body

    echo ""
    echo "POST $base_url$endpoint via MCP..."
    echo "curl -X POST -H \"$auth_header\" -H \"Content-Type: application/json\" -d '$body' \"$base_url$endpoint\""
}

connect_graphql_api() {
    echo "GraphQL API Configuration:"
    read -p "GraphQL endpoint URL: " endpoint
    read -s -p "Authorization token (optional): " token
    echo ""

    read -p "GraphQL query: " query

    echo ""
    echo "Executing GraphQL query via MCP..."
    echo "curl -X POST -H \"Authorization: Bearer $token\" -H \"Content-Type: application/json\" -d '{\"query\":\"$query\"}' \"$endpoint\""
}

connect_api "$ARGUMENTS"

Phase 5: Cloud Service Integration

Connect to cloud providers:

#!/bin/bash
# Connect to cloud services via MCP

connect_cloud() {
    local provider="${1:-aws}"

    echo "=== Cloud Service Connection ==="
    echo ""

    case $provider in
        aws)
            connect_aws
            ;;
        gcp)
            connect_gcp
            ;;
        azure)
            connect_azure
            ;;
    esac
}

connect_aws() {
    echo "AWS Services:"
    echo "  1. S3 (Object Storage)"
    echo "  2. DynamoDB (Database)"
    echo "  3. Lambda (Functions)"
    echo "  4. EC2 (Compute)"
    echo "  5. CloudWatch (Monitoring)"
    echo ""

    read -p "Select service (1-5): " SERVICE

    case $SERVICE in
        1) aws_s3_operations ;;
        2) aws_dynamodb_operations ;;
        3) aws_lambda_operations ;;
        4) aws_ec2_operations ;;
        5) aws_cloudwatch_operations ;;
    esac
}

aws_s3_operations() {
    echo "S3 Operations:"
    read -p "Bucket name: " bucket

    echo "  1. List objects"
    echo "  2. Upload file"
    echo "  3. Download file"
    echo "  4. Delete object"
    echo ""

    read -p "Select operation (1-4): " OPERATION

    case $OPERATION in
        1)
            echo "Listing objects in $bucket via MCP..."
            echo "aws s3 ls s3://$bucket"
            ;;
        2)
            read -p "Local file path: " file
            read -p "S3 key: " key
            echo "Uploading $file to s3://$bucket/$key via MCP..."
            echo "aws s3 cp $file s3://$bucket/$key"
            ;;
        3)
            read -p "S3 key: " key
            read -p "Local destination: " dest
            echo "Downloading s3://$bucket/$key to $dest via MCP..."
            echo "aws s3 cp s3://$bucket/$key $dest"
            ;;
        4)
            read -p "S3 key: " key
            echo "Deleting s3://$bucket/$key via MCP..."
            echo "aws s3 rm s3://$bucket/$key"
            ;;
    esac
}

aws_dynamodb_operations() {
    read -p "Table name: " table

    echo "DynamoDB Operations:"
    echo "  1. Query items"
    echo "  2. Put item"
    echo "  3. Update item"
    echo "  4. Delete item"
    echo ""

    read -p "Select operation (1-4): " OPERATION

    case $OPERATION in
        1)
            read -p "Query expression: " query
            echo "Querying $table via MCP..."
            echo "aws dynamodb query --table-name $table --key-condition-expression \"$query\""
            ;;
        2)
            read -p "Item (JSON): " item
            echo "Putting item in $table via MCP..."
            echo "aws dynamodb put-item --table-name $table --item \"$item\""
            ;;
    esac
}

connect_cloud "$ARGUMENTS"

Phase 6: Project Tool Integration

Connect to project management and collaboration tools:

#!/bin/bash
# Connect to project tools via MCP

connect_project_tool() {
    local tool="${1:-jira}"

    echo "=== Project Tool Connection ==="
    echo ""

    case $tool in
        jira)
            connect_jira
            ;;
        linear)
            connect_linear
            ;;
        slack)
            connect_slack
            ;;
        notion)
            connect_notion
            ;;
    esac
}

connect_jira() {
    echo "Jira Operations:"
    echo "  1. Create issue"
    echo "  2. List issues"
    echo "  3. Update issue"
    echo "  4. Search issues"
    echo ""

    read -p "Select operation (1-4): " OPERATION

    case $OPERATION in
        1)
            read -p "Project key: " project
            read -p "Issue type (Story/Bug/Task): " type
            read -p "Summary: " summary
            read -p "Description: " description

            echo "Creating Jira issue via MCP..."
            echo "jira issue create --project $project --type $type --summary \"$summary\" --description \"$description\""
            ;;
        2)
            read -p "Project key: " project
            echo "Listing issues in $project via MCP..."
            echo "jira issue list --project $project"
            ;;
    esac
}

connect_linear() {
    echo "Linear Operations:"
    echo "  1. Create issue"
    echo "  2. List issues"
    echo "  3. Update issue status"
    echo ""

    read -p "Select operation (1-3): " OPERATION

    case $OPERATION in
        1)
            read -p "Team ID: " team
            read -p "Title: " title
            read -p "Description: " description

            echo "Creating Linear issue via MCP..."
            # Linear API call via MCP
            ;;
    esac
}

connect_slack() {
    echo "Slack Operations:"
    echo "  1. Send message"
    echo "  2. Read channel history"
    echo "  3. Create channel"
    echo ""

    read -p "Select operation (1-3): " OPERATION

    case $OPERATION in
        1)
            read -p "Channel: " channel
            read -p "Message: " message

            echo "Sending Slack message via MCP..."
            echo "slack chat send --channel $channel --text \"$message\""
            ;;
    esac
}

connect_project_tool "$ARGUMENTS"

Practical Examples

Connect to GitHub:

/tool-connect github
/tool-connect github owner/repo

Connect to Database:

/tool-connect postgres
/tool-connect mongodb
/tool-connect redis

Connect to API:

/tool-connect rest https://api.example.com
/tool-connect graphql https://api.example.com/graphql

Connect to Cloud:

/tool-connect aws s3
/tool-connect gcp storage
/tool-connect azure blob

Connect to Tools:

/tool-connect jira
/tool-connect linear
/tool-connect slack

Security Best Practices

Credential Management:

• ✅ Store credentials in environment variables
• ✅ Use MCP server env configuration
• ✅ Never commit secrets to version control
• ✅ Use minimal permission scopes

Access Control:

• ✅ Use read-only credentials when possible
• ✅ Limit API access to necessary endpoints
• ✅ Implement rate limiting
• ✅ Monitor API usage

Troubleshooting

Connection Failed:

# Test connectivity
curl -I https://api.github.com

# Verify credentials
echo $GITHUB_TOKEN

# Check MCP config
cat ~/.claude/config.json | python -m json.tool

Authentication Issues:

# Test GitHub token
curl -H "Authorization: token $GITHUB_TOKEN" https://api.github.com/user

# Test database connection
psql "$POSTGRES_CONNECTION_STRING" -c "SELECT 1;"

What I'll Actually Do

1. Check prerequisites - Verify MCP setup
2. Select tool - Choose integration target
3. Configure connection - Set up credentials
4. Test connectivity - Verify access
5. Demonstrate operations - Show available actions

Important: I will NEVER:

• Store credentials insecurely
• Access tools without permission
• Skip authentication validation
• Add AI attribution

All tool connections will be secure, properly configured, and well-documented.

Credits: Based on Model Context Protocol and official MCP server implementations for various services.