Third-Party Integrations

Building powerful workflows with Claude Code often means connecting to external services and tools. This lesson explores how to integrate Claude Code with third-party systems, from databases to cloud platforms, creating a unified development environment that amplifies your productivity.

The Integration Landscape

Scenario: You’re building a microservices architecture that needs to coordinate between GitHub for version control, PostgreSQL for data, Sentry for error monitoring, and AWS for deployment. Instead of juggling multiple tools, you want Claude to orchestrate everything.

Claude Code’s integration capabilities center around the Model Context Protocol (MCP), which provides a standardized way to connect external tools and services. Think of MCP servers as specialized assistants that Claude can call upon - each one expert in its domain.

Understanding MCP: Your Gateway to External Services

The Model Context Protocol is Claude’s bridge to the outside world. When you connect an MCP server, you’re essentially giving Claude new capabilities - the ability to query databases, interact with APIs, or control cloud services.

Setting Up Your First MCP Server

Let’s start with a practical example: connecting to a PostgreSQL database.

Add the PostgreSQL MCP server

claude mcp add postgres-local npx -y @modelcontextprotocol/server-postgresql -- \
  --connection-string "postgresql://user:pass@localhost:5432/myapp"

Verify the connection

claude mcp list
# You should see "postgres-local" in the list

Use it in Claude

> What tables exist in our database?
> Show me the schema for the users table
> Find all orders placed in the last week

Notice how Claude now understands your database structure? This is the power of MCP - Claude gains domain-specific knowledge and tools.

MCP Server Scopes: Local, Project, and User

Where you configure an MCP server determines who can use it:

# Project scope - shared via .mcp.json (default)
claude mcp add github-api npx -y github-mcp-server

# User scope - available across all your projects
claude mcp add -s user my-tools /path/to/custom-server

# Local scope - just for you in this project
claude mcp add -s local dev-db docker run postgres-mcp

Pro tip: Use project scope for team tools, user scope for personal preferences, and local scope for sensitive connections.

Essential Integrations for Development Teams

GitHub Integration: Beyond Basic Git

While Claude can run git commands, the GitHub MCP integration unlocks powerful workflows:

# Add GitHub integration
claude mcp add github --transport sse \
  --url https://api.github.com/mcp \
  --header "Authorization: Bearer $GITHUB_TOKEN"

Now you can leverage GitHub’s full API:

> List all open issues labeled 'bug'
> Create a PR from the feature/auth branch with a detailed description
> Show me the review comments on PR #234
> What are the failing checks on our main branch?

Real-world scenario: Your team uses GitHub issues for task tracking. With the GitHub MCP server, you can say: “Find all issues assigned to me, pick the highest priority bug, create a branch, and start working on a fix.” Claude will:

Query GitHub for your assigned issues
Identify the highest priority bug
Create an appropriately named branch
Check out the branch locally
Begin implementing a solution based on the issue description

Database Integrations: Read-Only by Design

Database MCP servers are typically read-only for safety. This is a feature, not a limitation:

# Complex analytical queries become conversational
> Show me user growth by month for the past year
> Which products have the highest return rate?
> Find customers who haven't ordered in 90 days

# OLAP queries for analytics
claude mcp add analytics npx -y clickhouse-mcp-server \
  --host analytics.internal --port 8123

> Analyze page view trends for the marketing campaign
> Calculate conversion funnel metrics for Q4

# Cache and session management
claude mcp add cache npx -y @redis/mcp-redis \
  --url redis://localhost:6379

> Check cache hit rates for API endpoints
> List all active user sessions
> Debug why certain keys aren't expiring

Cloud Platform Integrations

Modern development often involves multiple cloud services. Claude can orchestrate them all:

AWS Integration

# Requires AWS CLI configured
claude mcp add aws npx -y aws-mcp-server

> List all EC2 instances in us-east-1
> Show me the Lambda functions with errors in the last hour
> Generate a Terraform config for our RDS setup

Google Cloud Integration

claude mcp add gcp --url https://mcp.cloudrun.googleapis.com/

> Deploy the current app to Cloud Run
> Check the status of our GKE clusters
> Update the Firebase security rules

Cloudflare Workers

claude mcp add cloudflare npx -y cloudflare-mcp

> Deploy the API to Workers
> Update the DNS records for the new subdomain
> Check R2 storage usage

Building Custom Integrations

Sometimes you need to integrate with internal tools or specialized services. Here’s how to approach custom integrations:

Using REST APIs Directly

Even without an MCP server, Claude can interact with APIs:

> Call our internal API at https://api.internal/v1/users with GET
> POST to https://webhook.site/... with this JSON payload: {...}
> Parse this webhook response and extract the order IDs

Creating Simple MCP Wrappers

For frequently used internal APIs, create a simple MCP wrapper:

import { MCPServer } from '@modelcontextprotocol/sdk';

const server = new MCPServer();

server.addTool('get_feature_flags', async (params) => {
  const response = await fetch('https://internal.api/flags');
  return await response.json();
});

server.addTool('toggle_feature', async (params) => {
  const response = await fetch(`https://internal.api/flags/${params.flag}`, {
    method: 'PATCH',
    body: JSON.stringify({ enabled: params.enabled })
  });
  return await response.json();
});

server.start();

Then add it to Claude:

claude mcp add feature-flags node /path/to/custom-api-mcp.js

Advanced Integration Patterns

Multi-Service Orchestration

Claude excels at coordinating multiple services. Here’s a real-world example:

“A customer reported an error. Check Sentry for details, find related logs in CloudWatch, identify the affected code, create a fix, and open a PR with the solution.”

With the right MCP servers configured, Claude will:

Query Sentry for the error details
Search CloudWatch logs for the timeframe
Identify the stack trace and affected files
Implement a fix based on the error pattern
Create tests to prevent regression
Open a PR with full context

CI/CD Integration

Integrate Claude into your deployment pipeline:

GitHub Actions Integration

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]
  issue_comment:
    types: [created]

jobs:
  claude-action:
    runs-on: ubuntu-latest
    if: >
      github.event_name == 'issue_comment' &&
      github.event.issue.pull_request &&
      contains(github.event.comment.body, '@claude')
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          api-key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: ${{ github.event.comment.body }}

Now team members can comment “@claude fix the failing tests” on any PR, and Claude will push fixes directly to the branch.

Webhook Automation

Create webhooks that trigger Claude for automated workflows:

app.post('/webhook/deploy', async (req, res) => {
  const { branch, commit } = req.body;

  // Trigger Claude to validate deployment
  exec(`claude -p "Validate deployment readiness for ${branch} at ${commit}.
    Check: tests passing, no security issues, migrations ready"`);

  res.json({ status: 'validation started' });
});

Security Best Practices for Integrations

Managing Credentials

Never hardcode credentials. Use environment variables:

# Good: Reference environment variables
claude mcp add prod-db npx -y pg-mcp \
  --connection-string "$DATABASE_URL"

# Bad: Hardcoded credentials
claude mcp add prod-db npx -y pg-mcp \
  --connection-string "postgresql://admin:secretpass@..."

Limiting MCP Server Permissions

Configure minimal required permissions:

{
  "mcpServers": {
    "production-db": {
      "command": "npx",
      "args": ["pg-mcp-server"],
      "env": {
        "CONNECTION_STRING": "$PROD_DB_READONLY"
      }
    }
  }
}

OAuth for Remote Services

Use OAuth flows for third-party services:

# Claude will open browser for authentication
claude mcp add github --transport sse \
  --url https://api.github.com/mcp

> /mcp
# Select "Authenticate" for the GitHub server

Troubleshooting Integrations

Common Issues and Solutions

Problem: MCP server won’t connect

# Debug with verbose output
claude --mcp-debug

# Check server status
claude mcp list

Solution: Verify network access, check credentials, ensure the service is running

Problem: “Permission denied” when using tools

# Check allowed tools
claude config get allowedTools

# Add MCP tools to allowlist
claude config add allowedTools "mcp__github__*"

Problem: Slow MCP operations

# Set timeout for MCP operations
export MCP_TIMEOUT=30000  # 30 seconds

# Use local servers when possible
claude mcp add local-db stdio /usr/local/bin/pg-mcp

Real-World Integration Workflow

Let’s walk through a complete integration scenario:

Scenario: Your e-commerce platform needs a new recommendation engine that pulls data from multiple sources.

Set up data source integrations

# Product database
claude mcp add products pg-mcp --connection-string "$PRODUCT_DB"

# User analytics
claude mcp add analytics clickhouse-mcp --host analytics.local

# Cache layer
claude mcp add cache redis-mcp --url redis://cache:6379

Design the system with Claude

> Based on our product catalog and user analytics data, design a
> recommendation system. Consider: purchase history, browsing patterns,
> and product similarities. Show me the schema and data flow.

Implement with real data

> Implement the recommendation algorithm. Test it with actual user
> data for customer_id=12345. Cache the results in Redis with 1-hour TTL.

Deploy and monitor

> Create a deployment script for AWS Lambda. Include CloudWatch
> alerts for response time > 500ms and error rate > 1%.

Best Practices for Production Integrations

Version your MCP configurations - Check .mcp.json into git
Use environment-specific configs - Separate dev/staging/prod MCP servers
Monitor MCP server health - Set up alerts for connection failures
Implement circuit breakers - Gracefully handle service outages
Document integration points - Keep CLAUDE.md updated with available integrations

Next Steps

Integrations transform Claude Code from a coding assistant into a development platform. Start with one or two essential integrations, then gradually expand as you identify workflow bottlenecks. Remember: the goal isn’t to integrate everything, but to create a seamless development experience that amplifies your team’s capabilities.

Ready to automate your development pipeline? The next lesson covers Automation, where we’ll build on these integrations to create self-running workflows.