explainx / blog
The definitive guide to Claude connectors and MCP servers. Learn how to set up custom connectors, integrate external tools, build your own MCP servers, and automate workflows with Claude AI in 2026.
Jun 9, 2026
AI marketing agents transform how businesses scale content, SEO, email, and social media. This comprehensive guide shows you how to build production-ready marketing agents with Claude, integrate with Ahrefs and Google Analytics, and measure real ROI from marketing automation.
Jun 27, 2026
AI agents are not smarter chatbots β they are a fundamentally different architecture. This guide explains what an agent actually is, walks through three real agent workflows step by step, and shows you how to build and use your first one.
Jun 9, 2026
Build professional full-stack websites using Claude AI without deep coding knowledge. This comprehensive tutorial covers vibe coding methodology, Claude Projects and Artifacts, React components, database setup, API integration, and deployment strategies for 2026.
TL;DR: Claude connectors revolutionize AI workflows by connecting Claude directly to external tools via Model Context Protocol (MCP) servers. This guide covers setting up custom connectors (Pro/Max/Team/Enterprise plans), MCP server authentication with OAuth 2.0, building your own remote MCP servers, and real-world automation workflows. Whether you're integrating databases, APIs, or custom tools, this is your complete roadmap to extending Claude's capabilities in 2026.
Claude connectors allow you to connect Claude AI directly to the tools and data sources that matter most to your workflows.
Custom connectors enable Claude to:
At the heart of Claude connectors is the Model Context Protocol (MCP):
What is MCP?
Why MCP Matters:
Sources: Claude Help Center, Claude Code Docs, Sunpeak AI
Before setting up Claude connectors, ensure you have:
| Requirement | Details |
|---|---|
| Claude Plan | Pro ($20/month), Max ($40/month), Team, or Enterprise plan |
| Remote MCP Server | Publicly accessible HTTPS endpoint |
| OAuth Credentials | Client ID and Client Secret (optional but recommended) |
| Internet Access | Server must be reachable from Anthropic's IP ranges |
Understanding the connection flow is crucial for effective implementation:
User Action:
What Happens:
User Action:
What Happens:
Automatic Process:
Result:
Example End-to-End:
User: "What are my top 3 GitHub issues this week?"
β Claude identifies need for GitHub connector
β MCP server queries GitHub API with user's OAuth token
β Returns structured list of issues
β Claude formats and presents: "Here are your top 3 GitHub issues..."
Sources: Truthifi MCP Guide, Toolradar Blog
For Claude Pro and Max users, adding custom connectors is straightforward:
1. Access Connector Settings
2. Add Remote MCP Server
https://mcp.example.com)3. Configure Authentication (Advanced Settings)
4. Save and Test Connection
Important: Connectors are enabled per conversation, not globally.
To Enable:
Why Per-Conversation?
| Issue | Solution |
|---|---|
| "Connection failed" | Verify URL is HTTPS and publicly accessible |
| "Authentication error" | Double-check OAuth Client ID and Secret |
| "Server unreachable" | Ensure server is online and not behind firewall |
| "Permission denied" | Verify OAuth scopes match required permissions |
Sources: Claude API Docs, Obot AI
For Team and Enterprise plans, connector setup involves two roles:
Step 1: Add Connectors to Organization
Step 2: Review and Approve
Step 3: Notify Team Members
Step 1: Connect to Organization Connector
Step 2: Authenticate Individually
Step 3: Enable in Conversations
Security by Design:
Example Scenario:
Organization adds GitHub connector (Owner action)
β Alice authenticates with her GitHub account (can access Repo A)
β Bob authenticates with his GitHub account (can access Repo B)
β Claude respects individual permissions
β Alice cannot access Bob's repos through Claude, and vice versa
Sources: MCP Playground, Get Ryze AI
Want to connect Claude to custom tools or proprietary systems? Build your own MCP server.
MCP Server Components:
βββββββββββββββββββββββββββββββββββββββββββ
β Your MCP Server β
βββββββββββββββββββββββββββββββββββββββββββ€
β 1. HTTP/HTTPS Endpoint β
β 2. MCP Protocol Handler β
β 3. OAuth 2.0 Authentication β
β 4. Tool Discovery & Execution β
β 5. External API Integration β
βββββββββββββββββββββββββββββββββββββββββββ
β β
Request from Response to
Claude Cloud Claude Cloud
Must-Haves:
| Requirement | Details |
|---|---|
| Public HTTPS URL | Must be reachable from Anthropic's IP ranges |
| MCP Protocol | Implement MCP specification for tool discovery |
| OAuth 2.0 | Handle authentication flow and token management |
| JSON API | Structured request/response format |
| Error Handling | Graceful failures and informative error messages |
1. FastMCP (Python) - Recommended for Beginners
from fastmcp import FastMCP
mcp = FastMCP("My Custom Connector")
@mcp.tool()
def get_user_data(user_id: str) -> dict:
"""Fetch user data from external API"""
# Your API logic here
return {"user_id": user_id, "name": "John Doe"}
@mcp.tool()
def create_task(title: str, description: str) -> dict:
"""Create a task in external system"""
# Your task creation logic
return {"task_id": "123", "status": "created"}
if __name__ == "__main__":
mcp.run()
2. MCP SDK (Node.js) - For JavaScript Developers
import { MCPServer } from '@anthropic/mcp-sdk';
const server = new MCPServer({
name: 'My Custom Connector',
version: '1.0.0'
});
server.addTool({
name: 'getUserData',
description: 'Fetch user data from external API',
parameters: {
user_id: { type: 'string', required: true }
},
handler: async (params) => {
// Your API logic here
return { user_id: params.user_id, name: 'John Doe' };
}
});
server.listen(3000);
Critical for Security:
from authlib.integrations.flask_oauth2 import ResourceProtector
# OAuth Configuration
OAUTH_CLIENT_ID = "your-client-id"
OAUTH_CLIENT_SECRET = "your-client-secret"
OAUTH_REDIRECT_URI = "https://your-mcp-server.com/oauth/callback"
@app.route('/oauth/authorize')
def oauth_authorize():
"""Initiate OAuth flow"""
# Redirect user to OAuth provider
auth_url = generate_auth_url(
client_id=OAUTH_CLIENT_ID,
redirect_uri=OAUTH_REDIRECT_URI,
scopes=['read', 'write']
)
return redirect(auth_url)
@app.route('/oauth/callback')
def oauth_callback():
"""Handle OAuth callback"""
code = request.args.get('code')
# Exchange code for access token
token = exchange_code_for_token(code)
# Store token securely (encrypted)
store_user_token(user_id, token)
return "Authentication successful!"
Cloud Platforms:
| Platform | Pros | Pricing |
|---|---|---|
| Vercel | Easy deployment, automatic HTTPS | Free tier available |
| AWS Lambda | Serverless, scalable | Pay per request |
| GCP Cloud Run | Container-based, auto-scaling | Free tier, then pay-as-you-go |
| DigitalOcean | Simple VPS, full control | $6/month and up |
| Railway | Developer-friendly, quick setup | Free tier, then $5+ |
Deployment Checklist:
Sources: Generect MCP Guide, Claude Platform Docs
1. GitHub MCP
2. Slack MCP
3. Notion MCP
4. Google Workspace MCP
5. PostgreSQL MCP
6. Jira MCP
7. Stripe MCP
8. AWS MCP
9. Salesforce MCP
10. MongoDB MCP
Example 1: Automated Code Review
User: "Review all PRs assigned to me and summarize issues"
Claude (using GitHub MCP):
β Fetches open PRs where user is reviewer
β Analyzes code diffs
β Identifies potential issues
β Provides summary with recommendations
Output: "You have 3 PRs to review:
1. PR #445: Authentication refactor - Looks good, minor suggestion on error handling
2. PR #446: API optimization - Concerns about N+1 query in line 42
3. PR #447: UI update - Approved, ready to merge"
Example 2: Customer Support Workflow
User: "Show me high-priority support tickets from last 24 hours"
Claude (using Jira MCP + Slack MCP):
β Queries Jira for P0/P1 tickets
β Checks related Slack threads
β Correlates customer messages with tickets
β Prioritizes based on impact
Output: "5 high-priority tickets:
1. Ticket #789: Payment failure (Customer: Acme Corp) - Slack thread active
2. Ticket #790: API downtime report - Multiple customers affected
..."
Example 3: Data Analysis Pipeline
User: "Pull last month's sales data and create a summary report"
Claude (using PostgreSQL MCP + Google Sheets MCP):
β Queries PostgreSQL for sales data
β Performs aggregations and calculations
β Creates formatted report in Google Sheets
β Shares link with summary insights
Output: "Created sales report for May 2026:
- Total Revenue: $1.2M (β 15% MoM)
- Top Product: Enterprise Plan (40% of revenue)
- Growth Region: APAC (β 32% MoM)
View report: [Google Sheets link]"
Sources: Obot AI MCP Guide, Sunpeak AI Tutorial
1. Least Privilege Access
2. Token Management
3. Network Security
4. Error Handling
1. Caching
from functools import lru_cache
import time
@lru_cache(maxsize=128)
def get_user_data(user_id: str):
"""Cache frequently accessed user data"""
# Expensive API call
return fetch_from_external_api(user_id)
# Cache expires after 5 minutes
@timed_cache(seconds=300)
def get_live_metrics():
"""Cache real-time metrics briefly"""
return fetch_metrics_api()
2. Batch Operations
def batch_process_items(item_ids: list[str]):
"""Process multiple items in single API call"""
# Instead of N API calls, make 1 batch call
return external_api.batch_get(item_ids)
3. Async Operations
import asyncio
async def parallel_fetch():
"""Fetch from multiple sources simultaneously"""
results = await asyncio.gather(
fetch_github_data(),
fetch_jira_data(),
fetch_slack_data()
)
return combine_results(results)
Essential Metrics:
Logging Best Practices:
import logging
logger = logging.getLogger(__name__)
@mcp.tool()
def critical_operation(param: str):
logger.info(f"Operation started: {param}")
try:
result = perform_operation(param)
logger.info(f"Operation succeeded: {param}")
return result
except Exception as e:
logger.error(f"Operation failed: {param}, error: {str(e)}")
raise
Symptoms:
Solutions:
https:// not http://curl to verify server responds:
curl -I https://your-mcp-server.com/health
Symptoms:
Solutions:
Symptoms:
Solutions:
Symptoms:
Solutions:
Scenario: Automated incident response
@mcp.tool()
async def handle_incident(incident_id: str):
"""Complete incident response workflow"""
# 1. Get incident details from Jira
incident = await jira_api.get_incident(incident_id)
# 2. Create Slack channel for incident
channel = await slack_api.create_channel(
name=f"incident-{incident_id}",
members=incident['team']
)
# 3. Notify on-call engineer via PagerDuty
await pagerduty_api.create_alert(
incident_id=incident_id,
urgency='high'
)
# 4. Query metrics from PostgreSQL
metrics = await postgres.query(
"SELECT * FROM system_health WHERE timestamp > NOW() - INTERVAL '1 hour'"
)
# 5. Post summary to Slack
await slack_api.post_message(
channel=channel['id'],
text=format_incident_summary(incident, metrics)
)
return {
"status": "initiated",
"channel": channel['name'],
"alert_created": True
}
Scenario: Daily sales report generation
@mcp.tool()
def generate_daily_sales_report():
"""Generate and distribute daily sales report"""
# 1. Extract: Query sales database
sales_data = postgres.query("""
SELECT product, SUM(revenue) as total_revenue, COUNT(*) as orders
FROM sales
WHERE date = CURRENT_DATE - 1
GROUP BY product
ORDER BY total_revenue DESC
""")
# 2. Transform: Calculate metrics
total_revenue = sum(row['total_revenue'] for row in sales_data)
top_product = sales_data[0]['product']
# 3. Load: Create Google Sheet
sheet = google_sheets.create(
title=f"Sales Report - {today()}",
data=sales_data
)
# 4. Notify: Send to Slack
slack.post_message(
channel='#sales',
text=f"Daily Sales Report: ${total_revenue:,.2f} | Top Product: {top_product}",
attachments=[{"title": "View Report", "url": sheet.url}]
)
return {"report_url": sheet.url, "total_revenue": total_revenue}
Scenario: Automated customer setup
@mcp.tool()
async def onboard_new_customer(email: str, company: str):
"""Complete customer onboarding workflow"""
# 1. Create Stripe customer
customer = await stripe.create_customer(
email=email,
name=company
)
# 2. Provision database
db_creds = await aws.create_rds_instance(
name=f"db-{company.lower()}",
size='db.t3.micro'
)
# 3. Send welcome email via SendGrid
await sendgrid.send_email(
to=email,
subject="Welcome to our platform!",
html=render_template('welcome', customer=customer)
)
# 4. Create Notion workspace page
workspace = await notion.create_page(
parent='Customer Workspaces',
title=company,
properties={
'Customer ID': customer['id'],
'Database': db_creds['endpoint'],
'Status': 'Active'
}
)
# 5. Log to Slack
await slack.post_message(
channel='#customer-success',
text=f"New customer onboarded: {company} ({email})"
)
return {
"customer_id": customer['id'],
"workspace_url": workspace.url,
"database_endpoint": db_creds['endpoint']
}
Goal: Set up and use existing MCP connectors
Tasks:
Resources:
Goal: Build your first custom MCP server
Tasks:
Resources:
Goal: Build production-ready multi-tool workflows
Tasks:
Resources:
Q: Do Claude connectors work with Claude API?
A: Yes, MCP connectors can be used with both Claude.ai web interface and Claude API. For API usage, you'll need to implement the MCP protocol in your application and handle authentication server-side.
Q: Can I use multiple connectors in one conversation?
A: Absolutely! Enable multiple connectors per conversation, and Claude will intelligently determine which tools to use based on your prompts. For example, you can combine GitHub + Slack + Jira connectors for comprehensive project management.
Q: Are there usage limits for connectors?
A: Connector usage respects your Claude plan limits. Additionally, external APIs may have their own rate limits. Implement caching and optimization to stay within limits.
Q: Can connectors access local files?
A: Remote MCP servers cannot access local files directly. For local file access, use Claude Desktop with local MCP servers. Remote MCP is designed for cloud-based tools and APIs.
Q: How do I debug connector issues?
A: Check Claude's connection status in Settings > Connectors, review your MCP server logs, test your OAuth flow independently, and verify your server is publicly accessible via HTTPS. Use tools like Postman to test your MCP endpoints directly.
Q: Can I monetize my MCP server?
A: Yes! You can build and share MCP servers as paid services. Implement subscription management, usage tracking, and authentication to create commercial MCP connectors.
Ready to become an expert in Claude connectors, MCP servers, and AI automation?
The Complete AI Builder Bootcamp provides hands-on training in:
What You'll Build:
6 weeks. 12 live sessions. 350,000+ students trained.
Learn from Yash Thakker, founder of AISOLO Technologies, with personalized guidance, lifetime recording access, and a permanent Discord community.
Official Documentation:
Comprehensive Guides:
Setup Tutorials:
This comprehensive guide covers Claude connectors and MCP servers as of June 2026. Features, APIs, and best practices may evolve. Visit Claude Help Center for the latest official documentation.