The top 15 MCP servers for your AI projects

The Model Context Protocol (MCP) is quickly becoming the standard for connecting AI models to external tools and data. Already adopted by platforms like VS Code and Claude Desktop, MCP servers power everything from file system access and API integrations to database queries and automated workflows.

In this guide, we’ll walk through 15 essential MCP servers for web developers, including setup steps, real-world use cases, and tips to accelerate your AI development workflow. Whether you’re building code analysis tools, deploying applications, or managing content, these servers offer a powerful foundation.

Most MCP servers follow a consistent installation and interaction pattern. For a full walkthrough, check out this article on getting started with MCP servers, and refer to the official MCP documentation for deeper protocol details.

Below is a quick comparison table highlighting key features of each server, which we’ll explore further in the sections that follow:

Server Name	Primary Use Case	Key Features	Installation Method	Authentication Required	Transport Type	Official vs Community	Pricing/Free Tier
GitHub MCP Server	Code automation & analysis	Pull requests, code scanning, repository management	Docker container	GitHub Personal Access Token	stdio	Official (GitHub)	Free
MongoDB MCP Server	Database operations	Natural language queries, Atlas management, schema operations	npx package	MongoDB connection string or Atlas API	stdio	Official (MongoDB)	Free tier available
Azure MCP Server	Cloud service integration	Storage, Cosmos DB, Log Analytics, App Configuration	npx package	Azure credentials (automatic)	stdio/SSE	Official (Microsoft)	Pay-per-use
Auth0 MCP Server	Identity management	User management, application config, security auditing	npx package	OAuth 2.0 device flow	stdio	Official (Auth0)	Free tier available
Cloudflare MCP Server	Edge computing & CDN	Workers, observability, Radar insights, multiple specialized servers	Remote servers via mcp-remote	Cloudflare credentials	SSE	Official (Cloudflare)	Free tier available
Firebase MCP Server	Backend-as-a-Service	Firestore, Auth, Cloud Functions, project management	Firebase CLI	Firebase CLI authentication	stdio	Official (Google)	Free tier available
Google Cloud Run MCP Server	Serverless deployment	Container deployment, service management, project operations	npx/GitHub URL	Google Cloud SDK	stdio/SSE	Official (Google)	Pay-per-use
JetBrains MCP Server	IDE integration	Code intelligence, project analysis via IDE proxy	npx package + IDE plugin	None (local IDE connection)	stdio	Official (JetBrains)	Free with IDE
Docker MCP Server	Container management	Natural language container composition, lifecycle management	PyPI via uvx	None (Docker daemon access)	stdio	Community	Free
Figma MCP Server	Design-to-code automation	Design analysis, component extraction, Code Connect integration	Figma Desktop app or npx	Figma API token (community) or Desktop app	SSE/stdio	Official (Figma) + Community	Free with paid Figma plans
AWS MCP Server	Cloud infrastructure	Documentation, cost analysis, CDK, multiple specialized servers	uvx packages	AWS credentials	stdio	Official (AWS Labs)	Pay-per-use
Netlify MCP Server	JAMstack deployment	Site deployment, project management, CLI integration	npx package	Netlify CLI auth or PAT	stdio	Official (Netlify)	Free tier available
Prisma MCP Server	Database schema & ORM	Postgres database management, schema migrations, Console integration	Prisma CLI	Prisma Console authentication	stdio	Official (Prisma)	Free tier available
Apollo MCP Server	GraphQL API integration	Persisted queries, schema introspection, federated graphs	Rover CLI or binary	None (schema-based)	stdio/SSE	Official (Apollo)	Free with GraphQL endpoints
Playwright MCP Server	E2E testing automation	Browser automation, accessibility snapshots, cross-browser testing	npx package	None (local browser access)	stdio/SSE	Official (Microsoft)	Free

Now, let’s explore each of the 15 essential MCP servers that will transform your AI development workflow.

 

1. GitHub MCP server: Advanced code automation and analysis

The GitHub MCP server enables AI models to perform sophisticated code analysis, automate repository management, and enhance development workflows through natural language interactions. Let’s try out a sample setup and configuration:

# Using Docker (recommended)
{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here"
      }
    }
  }
}

# Configure toolsets (optional)
{
  "env": {
    "GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here",
    "GITHUB_TOOLSETS": "repos,issues,pull_requests,code_security"
  }
}

Sample use cases

Development teams use this server for automated pull request management, like creating, reviewing, and merging pull requests while analyzing code changes. Project managers leverage it for intelligent issue tracking, automatically creating and updating issues based on repository activity. Security teams use it for code scanning analysis, where AI can review security alerts and suggest remediation steps:

const prWorkflow = async (client) => {
 // Create pull request
 const pr = await client.callTool({
   name: 'create_pull_request',
   arguments: {
     owner: 'owner',
     repo: 'repo',
     title: 'Automated feature update',
     head: 'branch',
     base: 'main'
   }
 });

 // Get code scanning alerts
 const alerts = await client.callTool({
   name: 'list_code_scanning_alerts',
   arguments: {
     owner: 'owner',
     repo: 'repo'
   }
 });

 return { pullRequest: pr, securityAlerts: alerts };
};

2. MongoDB MCP server: Natural language database operations

The MongoDB MCP server transforms database interactions by enabling natural language queries and intelligent data exploration. This server bridges the gap between AI models and MongoDB databases. With that, developers can perform complex operations without writing traditional query syntax.

This MCP server supports both direct database operations (find, aggregate, insert, update, delete) and MongoDB Atlas management tools, making for easy cluster administration, user management, and project configuration.

Here’s a sample installation and setup:

# Using MongoDB connection string
{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": [
        "-y", "mongodb-mcp-server",
        "--connectionString",
        "mongodb+srv://username:[email protected]/myDatabase"
      ]
    }
  }
}

# Using Atlas API credentials
{
  "mcpServers": {
    "MongoDB": {
      "command": "npx",
      "args": ["-y", "mongodb-mcp-server"],
      "env": {
        "MDB_MCP_API_CLIENT_ID": "your-atlas-client-id",
        "MDB_MCP_API_CLIENT_SECRET": "your-atlas-client-secret"
      }
    }
  }
}

Sample applications

E-commerce platforms use this server for intelligent product recommendations, where AI models analyze customer behavior data and generate personalized suggestions through aggregation pipelines:

// Natural language database operations
const productAnalysis = await client.callTool({
 name: 'aggregate',
 arguments: {
   collection: 'products',
   pipeline: [
     { $match: { stock: { $lt: 10 } } },
     { $lookup: { from: 'orders', localField: '_id', foreignField: 'productId', as: 'orders' } },
     { $addFields: { orderCount: { $size: '$orders' } } },
     { $sort: { orderCount: -1 } }
   ]
 }
});

// Get collection schema for AI understanding
const schema = await client.callTool({
 name: 'collection-schema',
 arguments: {
   collection: 'products'
 }
});

3. Azure MCP server: Cloud service integration

The Azure MCP server provides comprehensive integration with Microsoft Azure services, enabling AI models to manage cloud resources, deploy applications, and monitor infrastructure through natural language commands.

This includes Azure Storage for blob containers and tables, Cosmos DB for database management, Log Analytics for monitoring and querying, App Configuration for settings management, and direct Azure CLI/Azure Developer CLI command execution.

This server is particularly valuable for teams already invested in the Azure ecosystem. Here’s an example of how you’d set it up, and its configuration:

# One-click install for VS Code
# Add to .vscode/mcp.json
{
  "servers": {
    "Azure MCP Server": {
      "command": "npx",
      "args": ["-y", "@azure/mcp@latest", "server", "start"]
    }
  }
}

# Manual configuration for other MCP clients
{
  "mcpServers": {
    "azure": {
      "command": "npx",
      "args": ["-y", "@azure/mcp@latest", "server", "start"]
    }
  }
}

# For SSE transport (Server-Sent Events)
npx -y @azure/mcp@latest server start --transport sse

Use cases

DevOps teams use this server for intelligent infrastructure management, while development teams leverage it for automated deployment workflows through Azure CLI integration and Azure Developer CLI commands. Operations teams use it for proactive monitoring to predict potential issues.

Here’s an example of what that might look like:

const resourceAnalysis = async (client) => {
 // List storage accounts
 const storageAccounts = await client.callTool({
   name: 'list_storage_accounts',
   arguments: {}
 });

 // Query Cosmos DB databases
 const cosmosDBs = await client.callTool({
   name: 'list_cosmosdb_accounts',
   arguments: {}
 });

 // Check Log Analytics for monitoring data
 const logQuery = await client.callTool({
   name: 'query_log_analytics',
   arguments: {
     workspace: 'my-workspace',
     query: 'AppMetrics | where TimeGenerated > ago(1h) | summarize avg(Value) by bin(TimeGenerated, 5m)'
   }
 });

 return { storage: storageAccounts, databases: cosmosDBs, metrics: logQuery };
};

4. Auth0 MCP server: Identity management automation

The Auth0 MCP server simplifies identity and access management by enabling natural language commands for Auth0 tenants. It supports tasks like managing applications, configuring resource servers, developing and deploying actions, analyzing logs, and customizing forms, all through Auth0’s identity platform.

Here’s a sample setup process:

# Quick setup for Claude Desktop
npx @auth0/auth0-mcp-server init

# Read-only access for security
npx @auth0/auth0-mcp-server init --read-only

# Specific client setup (Windsurf, Cursor)
npx @auth0/auth0-mcp-server init --client windsurf
npx @auth0/auth0-mcp-server init --client cursor

# Manual configuration for other MCP clients
{
  "mcpServers": {
    "auth0": {
      "command": "npx",
      "args": ["-y", "@auth0/auth0-mcp-server", "run"],
      "capabilities": ["tools"],
      "env": {
        "DEBUG": "auth0-mcp"
      }
    }
  }
}

Application examples

Security teams use this server for automated user access reviews, identifying potential security risks through log analysis. On the other hand, development teams might leverage it for application lifecycle management, creating and updating Auth0 applications with specific configurations. Compliance teams generate automated audit reports based on user access patterns and security policies.

const createApplicationWorkflow = async (client, appName, type) => {
 // Create new application
 const app = await client.callTool({
   name: 'auth0_create_application',
   arguments: {
     name: appName,
     app_type: type, // 'spa', 'native', 'regular_web', 'machine_to_machine'
     callbacks: ['https://example.com/callback']
   }
 });

 // Create corresponding API if needed
 const api = await client.callTool({
   name: 'auth0_create_resource_server',
   arguments: {
     name: `${appName} API`,
     identifier: `https://api.${appName.toLowerCase()}.com`,
     scopes: [{ value: 'read:profile', description: 'Read user profile' }]
   }
 });

 return { application: app, resourceServer: api };
};

// Security audit example
const auditRecentLogins = await client.callTool({
 name: 'auth0_list_logs',
 arguments: {
   q: 'type:s AND ip:"192.168.1.100"',
   per_page: 50
 }
});

 

5. Cloudflare MCP server: Edge computing and CDN management

The Cloudflare MCP server enables natural language control over Cloudflare’s global network, from DNS configuration to edge deployments. It connects to services like Workers, observability tools, Radar, container and browser management, Logpush analytics, AI Gateway, and DNS analytics—each exposed through dedicated remote server endpoints.

Here’s an installation guide:

# For MCP clients with remote server support
# Use direct server URLs:
# - Main server: https://docs.mcp.cloudflare.com/sse
# - Workers Bindings: https://bindings.mcp.cloudflare.com/sse
# - Observability: https://observability.mcp.cloudflare.com/sse
# - Radar: https://radar.mcp.cloudflare.com/sse

# For clients without remote support, use mcp-remote
{
  "mcpServers": {
    "cloudflare-observability": {
      "command": "npx",
      "args": ["mcp-remote", "https://observability.mcp.cloudflare.com/sse"]
    },
    "cloudflare-bindings": {
      "command": "npx", 
      "args": ["mcp-remote", "https://bindings.mcp.cloudflare.com/sse"]
    },
    "cloudflare-radar": {
      "command": "npx",
      "args": ["mcp-remote", "https://radar.mcp.cloudflare.com/sse"]
    }
  }
}

Sample applications

Here are a few ways teams use the Cloudflare MCP Server in real-world applications:
Performance teams apply it to optimize caching strategies, automatically adjusting rules based on Radar traffic insights. Security teams use it to detect threats via observability data and deploy automated responses. Global apps benefit from intelligent traffic routing, tailoring content delivery based on user location and server performance.

Take a look at Radar’s MCP in action:

const edgeOptimization = async (observabilityClient, radarClient, bindingsClient) => {
 // Analyze current performance with observability server
 const performanceMetrics = await observabilityClient.callTool({
   name: 'get_analytics',
   arguments: {
     zone_id: 'your_zone_id',
     metrics: ['requests', 'bandwidth', 'response_time'],
     time_range: 'last_24h'
   }
 });

 // Get internet insights from Radar
 const radarInsights = await radarClient.callTool({
   name: 'get_traffic_insights',
   arguments: {
     location: 'global',
     time_range: 'last_week'
   }
 });

 return { metrics: performanceMetrics, insights: radarInsights };
};

6. Firebase MCP server: Backend-as-a-Service integration

The Firebase MCP Server provides seamless integration with Google’s Firebase platform, enabling AI models to manage real-time databases, authentication, hosting, and cloud functions through natural language interactions. It also provides project initialization and SDK configuration tools. The configuration setup includes:

# Basic configuration for Claude Desktop
{
  "mcpServers": {
    "firebase": {
      "command": "npx",
      "args": ["-y", "firebase-tools", "experimental:mcp"]
    }
  }
}

# Optional configuration with project directory and feature filtering
{
  "mcpServers": {
    "firebase": {
      "command": "npx",
      "args": [
        "-y", "firebase-tools", "experimental:mcp",
        "--dir", "/path/to/project",
        "--only", "auth,firestore,storage"
      ]
    }
  }
}

# Requires Firebase CLI authentication
firebase login --reauth

Sample use cases

Teams often use this server for intelligent data synchronization, automatically optimizing sync strategies based on user behavior patterns from Firestore queries. Mobile development teams leverage it for automated push notification campaigns, sending personalized notifications through Cloud Messaging based on engagement data. Security teams benefit from user management automation, with automatic permission adjustments based on authentication patterns through Firebase Auth tools.

We can see how those mobile development applications work below:

const firebaseWorkflow = async (client) => {
 // Get current project information
 const project = await client.callTool({
   name: 'firebase_get_project',
   arguments: {}
 });

 // Query Firestore for user engagement data
 const userData = await client.callTool({
   name: 'firestore_query_collection',
   arguments: {
     collection: 'users',
     filter: 'lastActive > 2024-01-01'
   }
 });

 // Send targeted messages
 await client.callTool({
   name: 'messaging_send_message',
   arguments: {
     topic: 'high-engagement-users',
     notification: {
       title: 'Special Offer',
       body: 'Thanks for being an active user!'
     }
   }
 });

 return { project, userData };
};

7. Google Cloud Run MCP server: Serverless deployment automation

The Google Cloud Run MCP Server automates the deployment and management of containerized applications on Google’s serverless platform. The server provides comprehensive Cloud Run management, including direct file deployment, local folder deployment, service management, and Google Cloud project operations.

It supports both local development workflows and remote deployment scenarios with IAM authentication for secure access to Google Cloud resources:

# Local setup (for AI-assisted IDEs like Cursor)
# Prerequisites: Node.js, Google Cloud SDK
gcloud auth login
gcloud auth application-default login

# Configuration for local deployment
{
  "mcpServers": {
    "cloud-run": {
      "command": "npx",
      "args": ["-y", "https://github.com/GoogleCloudPlatform/cloud-run-mcp"]
    }
  }
}

# Remote setup (MCP server on Cloud Run)
gcloud run deploy cloud-run-mcp \
  --image us-docker.pkg.dev/cloudrun/container/mcp \
  --no-allow-unauthenticated

# Create secure proxy connection
gcloud run services proxy cloud-run-mcp --port=3000 --region=REGION

# Configuration for remote deployment
{
  "mcpServers": {
    "cloud-run": {
      "url": "http://localhost:3000/sse"
    }
  }
}

Application scenarios

Microservices teams use this server for intelligent service deployment, as AI models can analyze application code and automatically deploy services with optimal configurations to Cloud Run. Development teams leverage it for automated deployment workflows, analyzing code changes, and deploying applications directly from IDEs or AI assistant applications.

DevOps teams benefit from project management automation, creating new Google Cloud projects, and managing service configurations across multiple environments:

const deploymentWorkflow = async (client, projectId, region) => {
 // List existing services
 const services = await client.callTool({
   name: 'list-services',
   arguments: {
     project: projectId,
     region: region
   }
 });

 // Deploy new application from local files
 const deployment = await client.callTool({
   name: 'deploy-local-folder',
   arguments: {
     folder_path: './my-app',
     service_name: 'my-new-service',
     project: projectId,
     region: region
   }
 });

 // Get deployment details
 const serviceDetails = await client.callTool({
   name: 'get-service',
   arguments: {
     service_name: 'my-new-service',
     project: projectId,
     region: region
   }
 });

 return { 
   existingServices: services, 
   newDeployment: deployment, 
   serviceInfo: serviceDetails 
 };
};

8. JetBrains MCP server: IDE integration and code intelligence

The JetBrains MCP Server bridges AI models with JetBrains IDEs, enabling intelligent code assistance, automated refactoring, and enhanced development

workflows directly within the IDE environment. The server provides deep integration with JetBrains IDEs, including IntelliJ IDEA, PyCharm, WebStorm, and Android Studio. This integration happens through a proxy architecture that connects MCP clients to the IDE’s built-in web server.

Here’s a sample configuration process:

# Install JetBrains MCP plugin from JetBrains Marketplace
# Plugin ID: 26071-mcp-server
# URL: https://plugins.jetbrains.com/plugin/26071-mcp-server

# Basic configuration for Claude Desktop
{
  "mcpServers": {
    "jetbrains": {
      "command": "npx",
      "args": ["-y", "@jetbrains/mcp-proxy"]
    }
  }
}

# Configuration for specific IDE instance
{
  "mcpServers": {
    "jetbrains": {
      "command": "npx",
      "args": ["-y", "@jetbrains/mcp-proxy"],
      "env": {
        "IDE_PORT": "63342",
        "HOST": "127.0.0.1",
        "LOG_ENABLED": "true"
      }
    }
  }
}

# External access configuration (for Docker/remote clients)
{
  "mcpServers": {
    "jetbrains": {
      "command": "sh",
      "args": ["-c", "IDE_PORT=YOUR_IDE_PORT HOST=YOUR_LAN_IP npx -y @jetbrains/mcp-proxy"],
      "env": {
        "IDE_PORT": "63342",
        "HOST": "192.168.1.100"
      }
    }
  }
}

Development use cases

Code review teams use this server for automated code quality analysis, accessing IDE inspection results to provide detailed feedback on potential improvements, security vulnerabilities, and performance optimizations directly within the development environment.

Meanwhile, development teams leverage it for intelligent refactoring suggestions, with structural improvements based on code patterns from IDE analysis tools. Documentation teams benefit from automated code documentation generation, creating comprehensive documentation using code analysis and IDE context

The JetBrains MCP server at work with code quality inspections:

const ideWorkflow = async (client) => {
 // Connect to JetBrains IDE through MCP proxy
 const projectInfo = await client.callTool({
   name: 'get_project_structure',
   arguments: {}
 });

 // Analyze code quality using IDE inspections
 const codeAnalysis = await client.callTool({
   name: 'run_code_inspections',
   arguments: {
     scope: 'project',
     include_warnings: true
   }
 });

 return {
   project: projectInfo,
   analysis: codeAnalysis
 };
};

9. Docker MCP server: Container management and orchestration

The Docker MCP server enables AI models to manage Docker containers, images, volumes, and networks through natural language commands, streamlining containerized application development and deployment workflows.

The server provides comprehensive Docker management, including container lifecycle control (create, start, stop, remove), image management (pull, push, build, remove), volume and network management, and natural language composition of multi-container applications. It supports both local Docker environments and remote Docker engines for server administration.

Let’s see a sample setup and some necessary configuration:

# Install from PyPI with uv (recommended)
{
  "mcpServers": {
    "mcp-server-docker": {
      "command": "uvx",
      "args": ["mcp-server-docker"]
    }
  }
}

# Alternative: Docker container installation
docker build -t mcp-server-docker .

{
  "mcpServers": {
    "mcp-server-docker": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-v", "/var/run/docker.sock:/var/run/docker.sock",
        "mcp-server-docker:latest"
      ]
    }
  }
}

# Development setup with devbox
{
  "mcpServers": {
    "docker": {
      "command": "/path/to/repo/.devbox/nix/profile/default/bin/uv",
      "args": ["--directory", "/path/to/repo/", "run", "mcp-server-docker"]
    }
  }
}

Operational use cases

Development teams use this server to analyze project requirements and automatically configure Docker environments with appropriate dependencies and configurations through natural language descriptions. DevOps teams leverage it to analyze container performance using stats resources and suggest improvements for image size, security, and resource usage. Testing teams use it to spin up isolated testing environments based on specific testing requirements using compose-style deployments.

Here’s how you might do that with Docker’s MCP server:

const deployWordPress = async (client, projectName) => {
 // Create containers with natural language description
 const deployment = await client.callTool({
   name: 'create_container',
   arguments: {
     project_name: projectName,
     description: 'deploy a WordPress container and a supporting MySQL container, exposing WordPress on port 9000'
   }
 });

 // Check logs for troubleshooting
 const logs = await client.callTool({
   name: 'fetch_container_logs',
   arguments: {
     container_id: deployment.wordpress_container,
     lines: 50
   }
 });

 return { deployment, logs };
};

// Natural language container orchestration
const nginxDeployment = await client.callTool({
 name: 'create_container',
 arguments: {
   project_name: 'web-server',
   description: 'deploy an nginx container exposing it on port 9000'
 }
});

10. Figma MCP server: Design-to-Code automation

The Figma MCP server provides AI models with direct access to Figma design files, enabling automated design analysis and code generation that bridges the gap between design and development. Here’s an installation setup:

# Official Figma Dev Mode MCP Server (requires Figma Desktop app)
# 1. Enable in Figma Desktop: Preferences > Enable Dev Mode MCP Server
# 2. Server runs at http://localhost:3845/sse

# Configuration for SSE-compatible MCP clients
{
  "mcpServers": {
    "figma-dev-mode": {
      "url": "http://localhost:3845/sse"
    }
  }
}

# Community Figma Context MCP Server (requires Figma API token)
{
  "mcpServers": {
    "figma-context": {
      "command": "npx",
      "args": ["-y", "figma-developer-mcp", "--figma-api-key=YOUR_API_KEY", "--stdio"]
    }
  }
}

# Alternative community server (GLips/Figma-Context-MCP)
{
  "mcpServers": {
    "figma": {
      "command": "npx",
      "args": ["-y", "@glips/figma-context-mcp"],
      "env": {
        "FIGMA_ACCESS_TOKEN": "your_figma_token"
      }
    }
  }
}

Design workflow applications

Frontend teams use this server to analyze Figma designs and generate corresponding React, Vue, or Angular components with accurate styling and responsive behavior using tools like get_code and get_variable_defs.

Design systems teams use it to ensure consistency by extracting variables from implementations and comparing them against established design tokens and guidelines.

Take a look at the design implementation here:

const designToCode = async (figmaClient) => {
 // Get structured React + Tailwind representation
 const codeStructure = await figmaClient.callTool({
   name: 'get_code',
   arguments: {
     selection: 'current_figma_selection'
   }
 });

 // Extract design variables and tokens
 const designTokens = await figmaClient.callTool({
   name: 'get_variable_defs',
   arguments: {
     frame_id: 'frame_id_from_url'
   }
 });

 return {
   reactCode: codeStructure,
   designTokens: designTokens
 };
};

// Community Figma Context MCP workflow
const simplifiedDesignData = await client.callTool({
 name: 'get_figma_data',
 arguments: {
   figma_url: 'https://figma.com/file/...',
   simplify_response: true
 }
});

11. AWS MCP server: Cloud infrastructure management

The AWS MCP server provides comprehensive integration with multiple specialized AWS services through dedicated MCP servers: AWS Documentation for accessing up-to-date service information, Amazon Bedrock Knowledge Bases for intelligent data retrieval, CDK for infrastructure as code, Cost Analysis for spend optimization, Amazon Nova Canvas for image generation, Terraform for multi-cloud infrastructure, Lambda function execution, and Diagrams for architecture visualization.

You can use the following configuration setup:

># Prerequisites: Install uv and configure AWS credentials
# Install uv from Astral: https://docs.astral.sh/uv/getting-started/installation/
uv python install 3.10

# Example configuration for multiple AWS MCP servers
{
  "mcpServers": {
    "awslabs.core-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.core-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR",
        "MCP_SETTINGS_PATH": "path/to/mcp/settings"
      }
    },
    "awslabs.aws-documentation-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-documentation-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cost-analysis-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cost-analysis-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-aws-profile",
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    },
    "awslabs.cdk-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.cdk-mcp-server@latest"],
      "env": {
        "FASTMCP_LOG_LEVEL": "ERROR"
      }
    }
  }
}

Cloud management applications

Infrastructure teams use this server to analyze usage patterns through the Cost Analysis server and automatically suggest cost-saving measures. Development teams leverage it for infrastructure as code workflows, where AI can generate CDK or Terraform configurations following AWS best practices through dedicated servers.

Take a closer look below:

const awsWorkflow = async (docClient, costClient, cdkClient, diagramClient) => {
 // Search AWS documentation for latest best practices
 const docResults = await docClient.callTool({
   name: 'search_documentation',
   arguments: {
     query: 'Lambda best practices security',
     max_results: 10
   }
 });

 // Analyze current costs and get recommendations
 const costAnalysis = await costClient.callTool({
   name: 'analyze_costs',
   arguments: {
     time_period: 'last_30_days',
     service: 'lambda',
     include_recommendations: true
   }
 });

 // Create architecture diagram
 const diagram = await diagramClient.callTool({
   name: 'create_diagram',
   arguments: {
     architecture_type: 'serverless',
     services: ['lambda', 'api-gateway', 'dynamodb']
   }
 });

 return { 
   documentation: docResults, 
   costs: costAnalysis, 
   architecture: diagram 
 };
};

12. Netlify MCP Server: JAMstack deployment and management

The Netlify MCP server provides comprehensive Netlify integration, including project creation and deployment from code editors, Netlify CLI functionality integration, extension management for enhanced functionality, and complete project lifecycle management.

It leverages both the Netlify API and CLI for seamless development workflow automation.

Below is a sample setup process:

# Prerequisites: Node.js 22+, Netlify account, Netlify CLI (recommended)
npm install -g netlify-cli

# Basic MCP configuration
{
  "mcpServers": {
    "netlify-mcp": {
      "command": "npx",
      "args": ["-y", "@netlify/mcp"]
    }
  }
}

# Configuration with Personal Access Token (temporary workaround for auth issues)
{
  "mcpServers": {
    "netlify-mcp": {
      "command": "npx",
      "args": ["-y", "@netlify/mcp"],
      "env": {
        "NETLIFY_PERSONAL_ACCESS_TOKEN": "your_pat_value"
      }
    }
  }
}

# Authentication check via CLI
netlify status
netlify login

JAMstack use cases

Frontend teams use the server for automated deployment optimization, allowing AI models to deploy projects directly from code editors and manage build configurations for faster load times. Development teams streamline project management by deploying Netlify projects and configuring settings based on project needs. Meanwhile, DevOps teams automate extension management by installing and configuring Netlify extensions to enhance functionality and performance monitoring.

Here’s how project deployment works with this MCP server:

const netlifyWorkflow = async (client, projectPath) => {
 // Create new Netlify project
 const project = await client.callTool({
   name: 'create_project',
   arguments: {
     name: 'my-jamstack-site',
     build_command: 'npm run build',
     publish_directory: 'dist'
   }
 });

 // Deploy current project
 const deployment = await client.callTool({
   name: 'deploy_site',
   arguments: {
     project_path: projectPath,
     production: true
   }
 });

 return {
   project: project,
   deployment: deployment
 };
};

13. Prisma MCP server: Database schema and ORM management

The Prisma MCP server offers comprehensive Prisma integration, including Prisma Postgres database management, schema migrations and table creation, database instance provisioning in specified regions, and Prisma Console authentication for visual database management. It operates through the Prisma CLI, using stdio (Standard Input/Output) transport for seamless integration with AI tools.

Let’s see a sample installation and setup for use:

# Basic configuration using Prisma CLI
{
  "mcpServers": {
    "Prisma": {
      "command": "npx",
      "args": ["-y", "prisma", "mcp"]
    }
  }
}

# Global configuration for Cursor (~/.cursor/mcp.json)
{
  "mcpServers": {
    "Prisma": {
      "command": "npx",
      "args": ["-y", "prisma", "mcp"]
    }
  }
}

# Claude Code terminal setup
claude mcp add prisma 
npx prisma mcp

# OpenAI Agents SDK integration
from openai.experimental.mcp import MCPServerStdio

async with MCPServerStdio(
    params={
        "command": "npx",
        "args": ["-y", "prisma", "mcp"]
    }
) as prisma_server:
    # AI agent with Prisma tools

Database development applications

Backend teams use the server to create database tables and manage schema migrations while maintaining data integrity. Development teams automate database provisioning, spinning up Prisma Postgres instances in optimal regions. Infrastructure teams handle Prisma Console authentication and enable visual database management through streamlined automation.

Here’s a more in-depth look:

>const prismaWorkflow = async (client) => {
 // Authenticate with Prisma Console
 const auth = await client.callTool({
   name: 'login_prisma_console',
   arguments: {}
 });

 // Create new database in optimal region
 const database = await client.callTool({
   name: 'create_database',
   arguments: {
     region: 'us-east-1',
     name: 'production-db'
   }
 });

 // Create new table with proper schema
 const table = await client.callTool({
   name: 'create_table',
   arguments: {
     database_id: database.id,
     table_name: 'Product'
   }
 });

 return {
   authentication: auth,
   database: database,
   table: table
 };
};

14. Apollo MCP server: GraphQL API integration

The Apollo MCP server enables AI models to interact with GraphQL APIs through Apollo’s ecosystem. That unlocks intelligent query building, schema analysis, and API optimization capabilities. The server provides comprehensive Apollo integration, including GraphQL operation exposure as MCP tools, persisted query management for pre-approved operations, schema introspection for dynamic operation discovery, and federated graph support through Apollo’s supergraph configuration. It supports both SSE (Server-Sent Events) and stdio transport mechanisms for flexible deployment options.

Here’s a configuration setup to follow:

# Install Apollo Rover CLI (v0.31+)
# Running with rover dev (SSE transport)
rover dev --supergraph-config ./graphql/supergraph.yaml \
  --mcp --sse-port 5000 \
  --mcp-operations ./operations/GetUsers.graphql ./operations/GetPosts.graphql

# SSE configuration for Claude Desktop
{
  "mcpServers": {
    "apollo-graphql": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://127.0.0.1:5000/sse",
        "--transport",
        "sse-first"
      ]
    }
  }
}

# stdio configuration for local binary
{
  "mcpServers": {
    "apollo-graphql": {
      "command": "/path/to/apollo-mcp-server",
      "args": [
        "--directory", "/path/to/graphql/config",
        "--schema", "api.graphql",
        "--operations", "operations/GetUsers.graphql", "operations/GetPosts.graphql",
        "--endpoint", "https://api.example.com/graphql"
      ]
    }
  }
}

# Using MCP Inspector for testing
npx @modelcontextprotocol/inspector
# Connect to http://localhost:5000/sse

API development use cases

API teams use this server for intelligent query optimization as AI models can analyze GraphQL operations and suggest improvements for better performance and reduced complexity through pre-approved persisted queries. Development teams can also leverage it for automated API client generation by creating optimized query builders and type definitions based on GraphQL schemas through introspection. Infrastructure teams use it for real-time API monitoring, analyzing query performance, and automatically implementing caching strategies through Apollo’s federated graph capabilities.

const apolloWorkflow = async (client) => {
 // Execute pre-approved persisted query
 const astronauts = await client.callTool({
   name: 'GetAstronautsCurrentlyInSpace',
   arguments: {
     variables: {}
   }
 });

 // Search for upcoming launches with parameters
 const launches = await client.callTool({
   name: 'SearchUpcomingLaunches',
   arguments: {
     variables: {
       search: 'SpaceX',
       limit: 10
     }
   }
 });

 // Get detailed astronaut information
 const astronautDetails = await client.callTool({
   name: 'GetAstronautDetails',
   arguments: {
     variables: {
       id: astronauts.data.astronauts[0].id
     }
   }
 });

 return {
   currentAstronauts: astronauts,
   upcomingLaunches: launches,
   astronautProfile: astronautDetails
 };
};

15. Playwright MCP Server: End-to-End testing automation

The Playwright MCP server offers comprehensive Playwright integration. That includes accessibility snapshot-based interactions for reliable automation, cross-browser support (Chrome, Firefox, WebKit, Edge), both headed and headless modes for different testing scenarios, as well as extensive browser capabilities including navigation, form interaction, file uploads, PDF generation, and tab management. It operates through structured accessibility data rather than pixel-based approaches for deterministic automation.

The setup and installation are detailed as below:

# Basic configuration for Claude Desktop or MCP clients
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

# VS Code installation
code --add-mcp '{"name":"playwright","command":"npx","args":["@playwright/mcp@latest"]}'

# Headless mode for background operations
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--headless"]
    }
  }
}

# Vision mode for screenshot-based interactions
{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest", "--vision"]
    }
  }
}

# SSE transport for remote access
npx @playwright/mcp@latest --port 8931
{
  "mcpServers": {
    "playwright": {
      "url": "http://localhost:8931/sse"
    }
  }
}

Testing workflow applications

QA teams use this server for intelligent test case generation, automatically creating comprehensive test suites by analyzing application functionality and using accessibility snapshots for reliable element interaction. Development teams leverage it for automated regression testing, monitoring application changes, and executing cross-browser testing workflows. Performance teams benefit from automated user journey testing, creating realistic user behavior scenarios across different browsers and devices using structured accessibility data.

Follow along with the user journey application below:

const playwrightTestSuite = async (client) => {
 // Take accessibility snapshot of current page
 const snapshot = await client.callTool({
   name: 'browser_snapshot',
   arguments: {}
 });

 // Navigate to application
 await client.callTool({
   name: 'browser_navigate',
   arguments: {
     url: 'https://myapp.com/login'
   }
 });

 // Fill login form using accessibility references
 await client.callTool({
   name: 'browser_type',
   arguments: {
     element: 'email input field',
     ref: 'input[type="email"]',
     text: '[email protected]'
   }
 });

 await client.callTool({
   name: 'browser_type',
   arguments: {
     element: 'password input field',
     ref: 'input[type="password"]',
     text: 'testpassword',
     submit: true
   }
 });

 // Verify login success by taking screenshot
 const screenshot = await client.callTool({
   name: 'browser_take_screenshot',
   arguments: {
     raw: false
   }
 });

 return {
   initialSnapshot: snapshot,
   loginScreenshot: screenshot
 };
};

Best practices for implementation and security

When deploying multiple MCP servers in production, use a centralized configuration system to securely manage auth tokens, service endpoints, and environment variables. Monitor the performance impact of each integration—MCP servers can introduce latency or failure points that affect AI response times.

Enforce strong security practices: apply rate limiting, cache responses when possible, and audit permissions regularly. Use robust error handling for network timeouts and consider circuit breakers for external service dependencies. Always store sensitive configuration data in environment variables or a credential manager—never in plain text.
Continuous monitoring of server health, latency, and error rates is essential to ensure high performance and secure access to your services and data.

Conclusion

The Model Context Protocol marks a major shift in how we build AI-powered applications. The 15 MCP servers covered here form the foundation for creating advanced, integrated workflows—whether you’re analyzing code with GitHub or automating deployments with Cloud Run.

Success with MCP depends on choosing servers that align with your tools and workflows. Start with integrations that complement your existing stack, then expand as you gain familiarity with the ecosystem. Whether you’re focused on developer tools, automation, or app performance, MCP gives you the flexibility to build smarter, more connected applications.