Combining Multiple MCPs: Build Powerful AI Workflows

TL;DR - Powerful MCP Combinations

Combine MCP servers for workflows that weren’t possible before:

🆕 2025: MCP donated to Agentic AI Foundation (AAIF)! Multi-agent workflows and remote MCP servers enable enterprise-scale orchestration. For an introduction to MCP, see the MCP Introduction guide.

Top Combinations:

Example Multi-Tool Prompt:

You: Check Sentry for critical errors, find the related code 
     in GitHub, and post a summary to #dev-alerts

Claude: [Uses Sentry to find errors]
        [Uses GitHub to locate code]
        [Uses Slack to post summary]
        
        Found 3 critical errors, analyzed root causes,
        posted summary with code links to #dev-alerts.

Understanding Multi-MCP Workflows

AI acts as the orchestrator between tools:

┌─────────────────────────────────────────────────────────────┐
│                   AI Orchestration                           │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   You: "Find bugs in Sentry, fix in GitHub, notify Slack"   │
│                          │                                   │
│                          ▼                                   │
│                    ┌─────────┐                               │
│                    │   AI    │                               │
│                    │ (Claude)│                               │
│                    └─────────┘                               │
│                    /    │    \                               │
│                   /     │     \                              │
│                  ▼      ▼      ▼                             │
│            ┌──────┐ ┌──────┐ ┌──────┐                        │
│            │Sentry│ │GitHub│ │Slack │                        │
│            │ MCP  │ │ MCP  │ │ MCP  │                        │
│            └──────┘ └──────┘ └──────┘                        │
│                                                              │
│   1. Query errors  2. Find code   3. Post message           │
│                                                              │
└─────────────────────────────────────────────────────────────┘

How It Works

1. You make a request involving multiple tools
2. AI breaks it down into steps
3. AI calls each MCP in sequence
4. Results flow through AI between tools
5. AI synthesizes the final output

2025: Multi-Agent Orchestration

For more on agentic AI, see the AI Agents guide. For workflow automation patterns, see the AI-Powered Workflows guide.

Essential Combinations

Combo 1: Developer Essentials

MCPs: GitHub + Filesystem + Git + Memory

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "..." }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", 
               "/Users/me/projects"]
    },
    "git": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-git",
               "--repository", "."]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Powerful workflows:

# Full code context
"Review my local changes, compare with the remote PR, 
 and suggest improvements"

# Intelligent commits
"Show my uncommitted changes, generate a good commit message,
 and remember this for the PR description"

# Codebase learning
"Explore this repository, learn the patterns, and remember
 them for future reference"

Combo 2: DevOps Pipeline

MCPs: GitHub + Sentry + Slack + AWS

For more on AI-powered DevOps, see the CLI Tools for AI guide.

{
  "mcpServers": {
    "github": { "...": "..." },
    "sentry": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-sentry"],
      "env": {
        "SENTRY_AUTH_TOKEN": "...",
        "SENTRY_ORGANIZATION": "my-org"
      }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "...",
        "SLACK_TEAM_ID": "..."
      }
    },
    "aws": {
      "command": "npx",
      "args": ["-y", "mcp-server-aws-cloudwatch"],
      "env": { "AWS_PROFILE": "production" }
    }
  }
}

Powerful workflows:

# Incident response
"Check Sentry for errors, correlate with CloudWatch metrics,
 find related code in GitHub, and post a summary to #incidents"

# Deployment verification
"After deploy, check Sentry for new errors, compare CloudWatch
 metrics, and alert #releases if anything looks wrong"

# Bug triage
"Find the top 3 Sentry errors, locate the code that caused them,
 create GitHub issues, and notify the team in #bugs"

Combo 3: Research & Documentation

MCPs: Firecrawl + Fetch + Memory + Filesystem

{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": { "FIRECRAWL_API_KEY": "..." }
    },
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/Users/me/research"]
    }
  }
}

Powerful workflows:

# Competitive analysis
"Crawl competitor.com, extract their features and pricing,
 remember the key points, and save a comparison report"

# Documentation gathering
"Fetch documentation from these 3 APIs, summarize the 
 differences, and save a reference guide locally"

# Learning new tech
"Research this framework, crawl its docs, remember the
 key patterns, and create a quick-start guide"

Combo 4: Infrastructure Management

MCPs: AWS + Cloudflare + PostgreSQL + Slack

{
  "mcpServers": {
    "aws": {
      "command": "npx",
      "args": ["-y", "mcp-server-aws-s3"],
      "env": { "AWS_PROFILE": "production" }
    },
    "cloudflare": {
      "command": "npx",
      "args": ["-y", "mcp-server-cloudflare"],
      "env": { "CLOUDFLARE_API_TOKEN": "..." }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "..." }
    },
    "slack": { "...": "..." }
  }
}

Powerful workflows:

# Full stack health check
"Check AWS resources, Cloudflare traffic, database performance,
 and post a health summary to #infrastructure"

# Cost analysis
"Analyze S3 storage costs, Cloudflare bandwidth usage, and 
 database size, then create a cost report"

# Security audit
"Check AWS security groups, Cloudflare firewall rules, and
 database user permissions, flag any issues to #security"

Combo 5: Productivity Hub

MCPs: Notion + Slack + Memory + Google Drive (if available)

For more on AI assistants for productivity, see the AI for Everyday Productivity guide.

{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-notion"],
      "env": { "NOTION_API_KEY": "..." }
    },
    "slack": { "...": "..." },
    "memory": { "...": "..." }
  }
}

Powerful workflows:

# Meeting follow-up
"Find my notes from yesterday's meeting in Notion, extract
 action items, remember who's responsible, and post to #team"

# Project status
"Check the project database in Notion, gather updates,
 and post a weekly summary to #projects"

# Knowledge management
"Learn our team processes from Notion, remember them,
 and help me answer questions about how we work"

Workflow Patterns

Pattern 1: Gather → Process → Distribute

┌─────────┐    ┌─────────┐    ┌─────────┐
│ Gather  │───▶│ Process │───▶│Distribute│
│(Sentry) │    │  (AI)   │    │ (Slack) │
└─────────┘    └─────────┘    └─────────┘

Example:

"Get today's errors from Sentry, summarize the patterns,
 and share in #daily-bugs"

Pattern 2: Research → Remember → Apply

┌──────────┐    ┌────────┐    ┌─────────┐
│ Research │───▶│Remember│───▶│  Apply  │
│(Firecrawl│    │(Memory)│    │(Response│
└──────────┘    └────────┘    └─────────┘

Example:

"Research Next.js 14 features, remember the key changes,
 and help me migrate my app"

Pattern 3: Query → Correlate → Report

┌─────────┐    ┌─────────┐    ┌─────────┐
│Source A │───▶│Correlate│───▶│ Report  │
│  (AWS)  │    │  (AI)   │    │(Filesys)│
└─────────┘    └─────────┘    └─────────┘
      ▲             │
      │    ┌─────────┐
      └────│Source B │
           │ (DB)    │
           └─────────┘

Example:

"Compare AWS costs with database query counts to find
 inefficient queries, save a report"

Pattern 4: Monitor → Alert → Act

┌─────────┐    ┌─────────┐    ┌─────────┐
│ Monitor │───▶│  Alert  │───▶│   Act   │
│ (AWS)   │    │ (Slack) │    │(GitHub) │
└─────────┘    └─────────┘    └─────────┘

Example:

"If CloudWatch shows high CPU, alert #ops and create
 a GitHub issue for investigation"

For more on building AI applications with these patterns, see the Building Your First AI Application guide.

Real-World Examples

Example 1: Daily Standup Automation

You: Prepare my standup update by checking:
     1. My GitHub activity yesterday
     2. Any Sentry issues assigned to me
     3. My tasks in Notion
     Then post a summary to #standup

Claude: [Queries GitHub for commits and PRs]
        [Checks Sentry for assigned issues]
        [Reads Notion task list]
        [Posts to Slack]
        
        Posted to #standup:
        
        📅 **Standup - Dec 24**
        
        **Yesterday:**
        - Merged PR #123: Auth bug fix
        - Resolved 2 Sentry issues
        
        **Today:**
        - Continue API refactor (Notion task)
        - Investigate timeout errors (Sentry)
        
        **Blockers:**
        - Waiting for design review

For comparison of AI assistants that can run these workflows, see the AI Assistants Comparison guide.

Example 2: Incident Response

You: We have a production incident. Check Sentry for errors,
     look at AWS CloudWatch for metrics, find related code,
     and create an incident report

Claude: [Queries Sentry for recent errors]
        [Checks CloudWatch for anomalies]
        [Searches GitHub for related code]
        [Compiles report]
        
        **Incident Report**
        
        **Summary:**
        Elevated error rate starting 14:32 UTC
        
        **Sentry Analysis:**
        - 156 TimeoutException errors
        - Affecting /api/checkout endpoint
        
        **CloudWatch Correlation:**
        - Database CPU spiked to 95% at 14:30
        - Query latency increased 10x
        
        **Root Cause (from code):**
        Likely caused by PR #456 which added unindexed query
        File: services/checkout.py line 234
        
        **Suggested Fix:**
        Add index on orders.customer_id column

Example 3: Weekly Report Generation

You: Generate our weekly engineering report:
     - PRs merged from GitHub
     - Errors resolved from Sentry  
     - Deploys from our CI
     Then save to /reports and post to #engineering

Claude: [Aggregates from multiple sources]
        [Saves to filesystem]
        [Posts to Slack]
        
        Saved: /reports/weekly-2024-12-24.md
        Posted to #engineering:
        
        📊 **Weekly Engineering Report**
        
        **Code:**
        - 23 PRs merged
        - 12,450 lines added
        - 4,230 lines removed
        
        **Quality:**
        - 45 Sentry issues resolved
        - Error rate: -23%
        - Crash-free: 99.2%
        
        **Deploys:**
        - 8 production deploys
        - 0 rollbacks

Tips for Effective Combinations

1. Start Simple

Week 1: Single MCP
Week 2: Add one more
Week 3: Combine in workflows
Week 4: Add complexity as needed

2. Be Explicit in Requests

❌ Vague: "Help me with my project"
✅ Clear: "Check GitHub for open PRs, summarize changes, 
          and post to #reviews"

3. Let AI Orchestrate

❌ Micromanaging: "First open GitHub, then query..."
✅ Goal-focused: "Find and fix the bug, then notify team"

4. Use Memory for Context

"Remember our team structure and project conventions"
"Learn this codebase for future reference"
"Store my preferences for reports"

For tips on crafting effective prompts, see the Prompt Engineering Fundamentals guide.

Troubleshooting Combinations

Issue: Workflow fails partway

Solution: Break into steps

"First, just check GitHub..."
"Now, query Sentry..."
"Finally, post to Slack..."

Issue: Too many results

Solution: Be specific

"Check only critical Sentry errors from today"
"Get PRs merged this week, not all time"

Issue: Confused context

Solution: Separate concerns

"Using the GitHub MCP for my personal account..."
"Now with the work GitHub MCP..."

Summary

Combining MCPs unlocks powerful workflows:

2025 Orchestration Options:

• Single AI orchestrating multiple MCPs
• Multi-agent systems with specialized agents
• LangChain + MCP for sophisticated workflows
• Remote MCP servers for enterprise scaling

Best practices:

• Start with 2-3 MCPs
• Be explicit in requests
• Use Memory for context
• Let AI orchestrate
• Build up complexity gradually

Next: Learn about Building Advanced MCP Servers → for custom integrations.

Questions about MCP combinations? Check the MCP specification or explore agentic frameworks like LangChain!