Discover Awesome MCP Servers

Metrx MCP Server

An MCP server for Metrx — provides tools for construction, healthcare, logistics, manufacturing, and legal mid-market businesses to query and analyze their operational data via AI.

PT-MCP (Paul Test Man Context Protocol)

Provides comprehensive codebase analysis and semantic understanding through integrated knowledge graphs, enabling AI assistants to understand project structure, patterns, dependencies, and context through multiple analysis tools and format generators.

Google Tag Manager MCP Server

Integrates Google Tag Manager with Claude to automate the creation and management of tags, triggers, and variables using natural language prompts. It provides specialized tools for GA4 and Facebook Pixel setup, along with automated tracking workflows for ecommerce and lead generation sites.

Redfish MCP Server

Enables AI agents and LLMs to control and monitor Redfish-enabled hardware through power operations, system inventory, event logs, health monitoring, sensor readings, and user account management.

Bybit MCP Server

A Model Context Protocol server that enables AI coding tools like Claude Code and Cursor to interact with Bybit's trading platform for market data retrieval, account management, and trading operations.

CodeBadger

Provides static code analysis using Joern's Code Property Graph technology for 12+ programming languages, enabling code browsing, security taint analysis, call graph exploration, and dataflow tracking through natural language queries.

JSON MCP Server

Provides powerful JSON manipulation tools through Model Context Protocol, enabling complex queries, schema generation, and validation with jq notation and native Node.js operations.

Database MCP Server

Provides universal database operations for AI assistants through MCP, supporting 40+ databases including PostgreSQL, MySQL, MongoDB, Redis, and SQLite with built-in introspection tools for schema exploration.

MCP Servers

Servidores MCP para trabalho de desenvolvimento.

agentfolio-mcp-server

MCP server for AgentFolio — the identity and reputation layer for AI agents. Query agent profiles, trust scores, verification status, and marketplace listings through 8 MCP tools.

MCP Strapi Server

Enables CRUD operations, content management, and media handling for any Strapi content type through standardized tools. Supports internationalization, schema management, and works with Strapi v5's API.

Yes or No MCP

A simple MCP server implementation in TypeScript that communicates over stdio, allowing users to ask questions that end with 'yes or no' to trigger the MCP tool in Cursor.

Medicare MCP Server

Provides comprehensive access to CMS Medicare data including physician services, prescriber information, hospital quality metrics, drug spending, formulary coverage, and ASP pricing for healthcare analysis and decision-making.

Google Slides MCP Server

Enables interaction with Google Slides presentations through OAuth2 authentication. Supports creating new slides, adding rectangles, and managing presentation content through natural language commands.

Docker MCP Server

Enables AI assistants to interact with Docker containers through safe, permission-controlled access to inspect, manage, and diagnose containers, images, and compose services with built-in timeouts and AI-powered analysis.

AutoSOC Agent

An automated security operations center MCP server that uses LLMs and network analysis tools like Tshark to detect threats in traffic data. It enables users to automatically ingest PCAP files, query specific packets, and generate intelligent security analysis reports.

Google Search MCP Server

Uma implementação de servidor MCP que se integra com a API JSON de Pesquisa Personalizada do Google, fornecendo capacidades de pesquisa na web.

Pytest MCP Server

Enables AI assistants to run and analyze pytest tests for desktop applications through interactive commands. Supports test execution, filtering, result analysis, and debugging for comprehensive test automation workflows.

flutterclimcp

Okay, here's a fun sample Flutter project idea using the Flutter CLI and a hypothetical "MCP (Model Context Protocol) Server" to illustrate how you might integrate data from an external source into your app: **Project Title:** "Recipe Roulette: What's for Dinner?" **Concept:** The app will randomly suggest recipes fetched from an MCP server. The MCP server, in this example, is a stand-in for any external API or data source that provides recipe information. **Why it's fun:** * **Practical:** Solves a common problem ("What should I cook?"). * **Randomness:** Adds an element of surprise. * **Extensible:** Easily expanded with features like filtering by cuisine, dietary restrictions, or ingredients. * **Illustrates Data Integration:** Demonstrates how to fetch and display data from an external source. **Steps (Assuming you have Flutter installed and configured):** **1. Project Setup (using Flutter CLI):** ```bash flutter create recipe_roulette cd recipe_roulette ``` **2. Hypothetical MCP Server (Conceptual - you'd need to implement this):** * **Imagine:** You have a server (written in Python, Node.js, Go, etc.) that exposes an endpoint like `/recipes/random`. * **Response:** This endpoint returns a JSON object representing a recipe: ```json { "id": 123, "name": "Spaghetti Carbonara", "ingredients": [ "Spaghetti", "Eggs", "Pancetta", "Pecorino Romano cheese", "Black pepper" ], "instructions": [ "Cook spaghetti according to package directions.", "Whisk eggs, cheese, and pepper.", "Fry pancetta until crispy.", "Combine everything and serve!" ], "imageUrl": "https://example.com/carbonara.jpg" } ``` **3. Flutter Code (Illustrative):** * **`lib/main.dart`:** ```dart import 'package:flutter/material.dart'; import 'dart:convert'; import 'package:http/http.dart' as http; void main() { runApp(const MyApp()); } class MyApp extends StatelessWidget { const MyApp({Key? key}) : super(key: key); @override Widget build(BuildContext context) { return MaterialApp( title: 'Recipe Roulette', theme: ThemeData( primarySwatch: Colors.blue, ), home: const RecipeRoulette(), ); } } class RecipeRoulette extends StatefulWidget { const RecipeRoulette({Key? key}) : super(key: key); @override _RecipeRouletteState createState() => _RecipeRouletteState(); } class _RecipeRouletteState extends State<RecipeRoulette> { Recipe? _recipe; bool _isLoading = false; Future<void> _fetchRecipe() async { setState(() { _isLoading = true; }); // Replace with your actual MCP server URL final url = Uri.parse('http://localhost:3000/recipes/random'); // Example URL try { final response = await http.get(url); if (response.statusCode == 200) { final jsonData = jsonDecode(response.body); setState(() { _recipe = Recipe.fromJson(jsonData); _isLoading = false; }); } else { // Handle error (e.g., show an error message) print('Error fetching recipe: ${response.statusCode}'); setState(() { _isLoading = false; }); ScaffoldMessenger.of(context).showSnackBar( const SnackBar(content: Text('Failed to load recipe.')), ); } } catch (e) { // Handle network errors print('Network error: $e'); setState(() { _isLoading = false; }); ScaffoldMessenger.of(context).showSnackBar( const SnackBar(content: Text('Network error. Please check your connection.')), ); } } @override Widget build(BuildContext context) { return Scaffold( appBar: AppBar( title: const Text('Recipe Roulette'), ), body: Center( child: _isLoading ? const CircularProgressIndicator() : _recipe == null ? const Text('Tap the button to get a recipe!') : RecipeCard(recipe: _recipe!), ), floatingActionButton: FloatingActionButton( onPressed: _fetchRecipe, tooltip: 'Get Recipe', child: const Icon(Icons.refresh), ), ); } } class Recipe { final int id; final String name; final List<String> ingredients; final List<String> instructions; final String? imageUrl; Recipe({ required this.id, required this.name, required this.ingredients, required this.instructions, this.imageUrl, }); factory Recipe.fromJson(Map<String, dynamic> json) { return Recipe( id: json['id'], name: json['name'], ingredients: List<String>.from(json['ingredients']), instructions: List<String>.from(json['instructions']), imageUrl: json['imageUrl'], ); } } class RecipeCard extends StatelessWidget { final Recipe recipe; const RecipeCard({Key? key, required this.recipe}) : super(key: key); @override Widget build(BuildContext context) { return Card( margin: const EdgeInsets.all(16.0), child: Padding( padding: const EdgeInsets.all(16.0), child: Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ if (recipe.imageUrl != null) Image.network( recipe.imageUrl!, width: double.infinity, height: 200, fit: BoxFit.cover, errorBuilder: (context, error, stackTrace) { return const Text('Image not available'); }, ), Text( recipe.name, style: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold), ), const SizedBox(height: 8), const Text( 'Ingredients:', style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold), ), for (var ingredient in recipe.ingredients) Text('- $ingredient'), const SizedBox(height: 8), const Text( 'Instructions:', style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold), ), for (var instruction in recipe.instructions) Text('- $instruction'), ], ), ), ); } } ``` **Explanation:** * **`Recipe` Class:** Represents the structure of a recipe. Includes `id`, `name`, `ingredients`, `instructions`, and an optional `imageUrl`. * **`RecipeRoulette` Widget:** * `_fetchRecipe()`: This is the core function. It makes an HTTP GET request to your hypothetical MCP server endpoint (`http://localhost:3000/recipes/random`). It uses the `http` package (you'll need to add it to your `pubspec.yaml` file). * Handles loading state (`_isLoading`) to show a `CircularProgressIndicator` while fetching data. * Parses the JSON response from the server using `jsonDecode`. * Creates a `Recipe` object from the parsed JSON. * Handles potential errors (e.g., server not found, invalid JSON). * **`RecipeCard` Widget:** Displays the recipe information in a nicely formatted card. * **`pubspec.yaml`:** Add the `http` package: ```yaml dependencies: flutter: sdk: flutter http: ^0.13.5 # Get the latest version from pub.dev ``` **4. Running the App:** 1. **Get Dependencies:** Run `flutter pub get` in your project directory. 2. **Run the App:** `flutter run` **Important Considerations:** * **MCP Server Implementation:** You'll need to *actually* create the MCP server. The code above assumes it exists and returns JSON in the specified format. You can use any language/framework you're comfortable with (Node.js with Express, Python with Flask/FastAPI, Go, etc.). A simple in-memory data structure (e.g., a list of recipe objects) is fine for a basic example. * **Error Handling:** The error handling in the example is basic. You should add more robust error handling (e.g., logging, more informative error messages to the user). * **Asynchronous Operations:** Fetching data from a server is an asynchronous operation. The `async` and `await` keywords are used to handle this. * **State Management:** For a more complex app, you might want to use a more sophisticated state management solution (Provider, Riverpod, BLoC, etc.). For this simple example, `setState` is sufficient. * **UI/UX:** This is a very basic UI. You can improve it with better styling, animations, and more user-friendly interactions. * **CORS:** If your Flutter app and MCP server are running on different domains (e.g., `localhost:5000` for the Flutter app and `localhost:3000` for the server), you'll need to configure CORS (Cross-Origin Resource Sharing) on your server to allow requests from your Flutter app's origin. **How to make it more fun:** * **Recipe Images:** Find a free API that provides recipe images (or use placeholder images). * **Animations:** Add animations when the recipe changes. * **User Preferences:** Allow users to filter recipes based on their preferences (e.g., cuisine, dietary restrictions). * **"Save" Recipes:** Let users save their favorite recipes to a list. * **Share Recipes:** Enable users to share recipes with friends. * **Voice Control:** Integrate voice control to fetch recipes using voice commands. This example provides a starting point. Adapt it to your specific needs and have fun building! Remember to replace the placeholder MCP server URL with the actual URL of your server. **Tradução para Português:** Aqui está uma ideia de projeto Flutter divertida usando o Flutter CLI e um hipotético "Servidor MCP (Model Context Protocol)" para ilustrar como você pode integrar dados de uma fonte externa em seu aplicativo: **Título do Projeto:** "Roleta de Receitas: O Que Tem Para Jantar?" **Conceito:** O aplicativo irá sugerir aleatoriamente receitas buscadas de um servidor MCP. O servidor MCP, neste exemplo, é um substituto para qualquer API ou fonte de dados externa que forneça informações sobre receitas. **Por que é divertido:** * **Prático:** Resolve um problema comum ("O que devo cozinhar?"). * **Aleatoriedade:** Adiciona um elemento de surpresa. * **Extensível:** Facilmente expandido com recursos como filtragem por culinária, restrições alimentares ou ingredientes. * **Ilustra a Integração de Dados:** Demonstra como buscar e exibir dados de uma fonte externa. **Passos (Assumindo que você tenha o Flutter instalado e configurado):** **1. Configuração do Projeto (usando o Flutter CLI):** ```bash flutter create recipe_roulette cd recipe_roulette ``` **2. Servidor MCP Hipotético (Conceitual - você precisaria implementar isso):** * **Imagine:** Você tem um servidor (escrito em Python, Node.js, Go, etc.) que expõe um endpoint como `/recipes/random`. * **Resposta:** Este endpoint retorna um objeto JSON representando uma receita: ```json { "id": 123, "name": "Spaghetti Carbonara", "ingredients": [ "Spaghetti", "Eggs", "Pancetta", "Pecorino Romano cheese", "Black pepper" ], "instructions": [ "Cook spaghetti according to package directions.", "Whisk eggs, cheese, and pepper.", "Fry pancetta until crispy.", "Combine everything and serve!" ], "imageUrl": "https://example.com/carbonara.jpg" } ``` **3. Código Flutter (Ilustrativo):** * **`lib/main.dart`:** (O código em Dart fornecido na resposta anterior) **Explicação:** * **Classe `Recipe`:** Representa a estrutura de uma receita. Inclui `id`, `name`, `ingredients`, `instructions` e um `imageUrl` opcional. * **Widget `RecipeRoulette`:** * `_fetchRecipe()`: Esta é a função principal. Ela faz uma requisição HTTP GET para o endpoint do seu servidor MCP hipotético (`http://localhost:3000/recipes/random`). Ela usa o pacote `http` (você precisará adicioná-lo ao seu arquivo `pubspec.yaml`). * Gerencia o estado de carregamento (`_isLoading`) para mostrar um `CircularProgressIndicator` enquanto busca os dados. * Analisa a resposta JSON do servidor usando `jsonDecode`. * Cria um objeto `Recipe` a partir do JSON analisado. * Lida com possíveis erros (por exemplo, servidor não encontrado, JSON inválido). * **Widget `RecipeCard`:** Exibe as informações da receita em um card formatado. * **`pubspec.yaml`:** Adicione o pacote `http`: ```yaml dependencies: flutter: sdk: flutter http: ^0.13.5 # Obtenha a versão mais recente de pub.dev ``` **4. Executando o Aplicativo:** 1. **Obtenha as Dependências:** Execute `flutter pub get` no diretório do seu projeto. 2. **Execute o Aplicativo:** `flutter run` **Considerações Importantes:** * **Implementação do Servidor MCP:** Você precisará *realmente* criar o servidor MCP. O código acima assume que ele existe e retorna JSON no formato especificado. Você pode usar qualquer linguagem/framework com a qual se sinta confortável (Node.js com Express, Python com Flask/FastAPI, Go, etc.). Uma estrutura de dados simples na memória (por exemplo, uma lista de objetos de receita) é suficiente para um exemplo básico. * **Tratamento de Erros:** O tratamento de erros no exemplo é básico. Você deve adicionar um tratamento de erros mais robusto (por exemplo, registro em log, mensagens de erro mais informativas para o usuário). * **Operações Assíncronas:** Buscar dados de um servidor é uma operação assíncrona. As palavras-chave `async` e `await` são usadas para lidar com isso. * **Gerenciamento de Estado:** Para um aplicativo mais complexo, você pode querer usar uma solução de gerenciamento de estado mais sofisticada (Provider, Riverpod, BLoC, etc.). Para este exemplo simples, `setState` é suficiente. * **UI/UX:** Esta é uma UI muito básica. Você pode melhorá-la com um estilo melhor, animações e interações mais amigáveis. * **CORS:** Se seu aplicativo Flutter e o servidor MCP estiverem sendo executados em domínios diferentes (por exemplo, `localhost:5000` para o aplicativo Flutter e `localhost:3000` para o servidor), você precisará configurar o CORS (Cross-Origin Resource Sharing) em seu servidor para permitir solicitações da origem do seu aplicativo Flutter. **Como tornar mais divertido:** * **Imagens de Receitas:** Encontre uma API gratuita que forneça imagens de receitas (ou use imagens de espaço reservado). * **Animações:** Adicione animações quando a receita mudar. * **Preferências do Usuário:** Permita que os usuários filtrem as receitas com base em suas preferências (por exemplo, culinária, restrições alimentares). * **"Salvar" Receitas:** Deixe os usuários salvarem suas receitas favoritas em uma lista. * **Compartilhar Receitas:** Permita que os usuários compartilhem receitas com amigos. * **Controle de Voz:** Integre o controle de voz para buscar receitas usando comandos de voz. Este exemplo fornece um ponto de partida. Adapte-o às suas necessidades específicas e divirta-se construindo! Lembre-se de substituir o URL do servidor MCP de espaço reservado pelo URL real do seu servidor.

Semantic Pen MCP Server

The official MCP server for Semantic Pen - an advanced AI article generator and SEO content writer. Create, manage, and optimize SEO-friendly articles directly from Claude Code and Cursor Windsurf with powerful AI automation.

DeFi Trading Agent MCP Server

Transforms AI assistants into autonomous crypto trading agents with real-time market analysis, portfolio management, and trade execution across 17+ blockchains.

Python Code Runner

Enables execution of Python code in a safe environment, including running scripts, installing packages, and retrieving variable values. Supports file operations and package management through pip.

Semrush Keyword Magic Tool MCP Server

Enables access to Semrush Keyword Magic Tool API for SEO keyword research, including keyword overview analysis, finding millions of keyword suggestions, and discovering question-based keywords across different countries and languages.

Claude Jester MCP

Transforms Claude from a code generator into a programming partner capable of testing, debugging, and optimizing code automatically through a secure execution environment.

DALL-E MCP Server

Enables AI assistants to generate high-quality images using OpenAI's DALL-E 3 model with configurable parameters like size, quality, and style. Generated images are automatically saved to the local filesystem with comprehensive error handling.

OpenSearch MCP Server

Enables LLMs to interact with OpenSearch clusters to monitor cluster health, manage indices, and perform data searches. It provides a standardized interface for real-time OpenSearch operations within MCP-compatible environments like Open WebUI.

GitHub Summary MCP

Generates daily GitHub work summaries by analyzing commits across all repositories a user owns or contributes to. It provides tools to fetch today's commit activity and deduplicate repository-specific updates for easy reporting.

MCP Sampling Demo

Demonstrates how to implement sampling in MCP servers, allowing tools to request LLM content generation from the client without requiring external API integrations or credentials.

Mcp Arcknowledge

This MCP server conveniently lets you configure and interact across all your custom webhook endpoints from a config(knowledgebase json). You can manage new endpoint knowledge doc sources URLs.