Tool Connect

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.