Discover Awesome MCP Servers

Agentic Developer MCP

An MCP server that wraps OpenAI's Codex CLI to automate repository cloning and code analysis tasks. It enables users to execute complex coding requests on specific Git branches and subfolders using standardized MCP tools.

MCP Cookie Server

A Model Context Protocol server that provides positive reinforcement for LLMs by awarding 'cookies' as treats through a jar-based economy system where Claude can earn cookies based on self-reflection about response quality.

browser-use MCP Server

Espelho de

Gemini Image Generation MCP Server

Enables image generation using Google's Gemini 2 API with customizable parameters like aspect ratio, number of samples, and person generation settings.

PubMed MCP Server

Enables searching and retrieving detailed information from PubMed articles using the NCBI Entrez API. Supports configurable search parameters including title/abstract filtering and keyword expansion to find relevant scientific publications.

Reddit MCP Server

Enables AI agents to search, monitor, and analyze Reddit's communities and discussions through authenticated API access with intelligent caching and rate limiting.

Security Testing MCP Server

Provides penetration testing tools including nmap, nikto, sqlmap, wpscan, and exploit database searches for educational and authorized security testing purposes using Kali Linux tools.

mcp-console-application

Um Servidor e Cliente MCP desenvolvidos a partir do guia de início rápido na documentação deles.

Minimal MCP

A basic educational MCP server that provides simple tools for mathematical calculations, text manipulation, and time retrieval. Designed for learning MCP implementation patterns and development purposes.

CoRT MCP Server

An MCP server implementing the Chain-of-Recursive-Thoughts (CoRT) methodology that makes AI think harder by making it argue with itself repeatedly through multiple rounds of alternative generation and evaluation.

mcp-file-server

MCP File System Server for Claude Desktop

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.

Git Polite

Enables AI agents to intelligently organize Git changes into clean, focused commits with autopilot mode or surgical line-by-line staging precision. Supports partial staging of untracked files and handles large diffs with smart truncation.

MCP Conductor

An orchestration system that coordinates multiple MCP servers to eliminate AI session startup overhead through intelligent project caching. It enables instant context loading and conversation continuity by synchronizing data across Memory, Filesystem, Git, and Database MCPs.

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.

Temporal Nexus Calculator MCP Server

Provides mathematical operations (expression evaluation, arithmetic, advanced calculations) through MCP, backed by Temporal workflows for reliability and durability. Demonstrates integration between Model Context Protocol tools and Temporal's Nexus RPC framework with full observability.

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.

Twilio Verify MCP Server

An MCP server that enables interaction with Twilio's Verify API, allowing users to manage phone verification services through natural language commands.

Pearch

This project provides a tool for searching people using the Pearch.ai, implemented as a FastMCP service.

ECharts MCP Server

Enables generation of various chart types (bar, line, pie, scatter, radar, heatmap, and more) using ECharts library, returning preview URLs to visualize data through natural language requests.

Pagila MCP

A read-only Model Context Protocol server developed with FastMCP for querying the Pagila PostgreSQL database. It enables secure access to movie rental data including films, actors, and customer information through natural language queries.

MCPStudio: The Postman for Model Context Protocol

Here are a few ways to interpret "Postman for MCP servers" and their corresponding translations: **1. If you're asking about using Postman (the API testing tool) to interact with an MCP (Minecraft Protocol) server:** * **Portuguese:** "Usando o Postman para interagir com servidores MCP (Protocolo Minecraft)" or "Postman para testar APIs de servidores MCP (Protocolo Minecraft)" * This implies you want to send requests to a Minecraft server using the Minecraft Protocol and test the responses. This is **highly unlikely** to be what you want, as the Minecraft Protocol is not a standard HTTP API. Postman is designed for HTTP APIs. **2. If you're asking about a tool *similar* to Postman, but specifically designed for interacting with Minecraft servers:** * **Portuguese:** "Uma ferramenta similar ao Postman para servidores Minecraft" or "Alternativa ao Postman para interagir com servidores Minecraft" * This is more likely. However, there isn't a direct equivalent to Postman for Minecraft servers. You'd typically use libraries or tools designed for the specific Minecraft server platform (e.g., Bukkit, Spigot, Fabric, Forge) and its plugin API. You'd write code to interact with the server. **3. If "MCP server" refers to something else entirely (e.g., a server running a specific application called "MCP"):** * **Portuguese:** This depends entirely on what "MCP" refers to. You'll need to provide more context. For example, if "MCP" is a specific software application, you might say: "Postman para servidores que executam o software MCP". **In summary, the most likely translation, assuming you're looking for a way to test interactions with a Minecraft server, is:** * **Portuguese:** "Não existe uma ferramenta como o Postman para interagir diretamente com servidores Minecraft. É necessário usar bibliotecas e APIs específicas da plataforma do servidor (Bukkit, Spigot, Fabric, Forge) para desenvolver código que interaja com ele." This translates to: "There isn't a tool like Postman to interact directly with Minecraft servers. You need to use libraries and APIs specific to the server platform (Bukkit, Spigot, Fabric, Forge) to develop code that interacts with it." **To give you a more accurate translation and helpful answer, please clarify what you mean by "MCP server".** What kind of server is it, and what are you trying to achieve with Postman (or a similar tool)?

MCP Weather Server

A Model Context Protocol server that provides tools to fetch weather alerts for US states and forecasts based on latitude/longitude coordinates using the US National Weather Service API.

Open States API MCP Server

This MCP server enables interaction with the Open States API, allowing users to access legislative data from US state governments through natural language commands.

Inoreader MCP Server

Enables intelligent RSS feed management and analysis through Inoreader integration. Supports reading articles, search, bulk operations, and AI-powered content analysis including summarization, trend analysis, and sentiment analysis.

Berghain Events MCP Server

A server that allows AI agents to query and retrieve information about upcoming events at Berghain nightclub through a DynamoDB-backed FastAPI service.

Tea Rags MCP

A high-performance MCP server for semantic search and codebase indexing using the Qdrant vector database. It features optimized embedding pipelines, AST-aware chunking, and git metadata enrichment for fast, privacy-focused local or remote search.

Ordinal-MCP

Implements a structured communication bus that allows AI agents to send 'oracle calls' to human operators for resolving complex decisions or judgment calls. It facilitates hierarchical message passing between agents and humans using a file-based request/response system with interaction history archiving.

USDC MCP Server

Enables AI agents and LLMs to interact with USDC API endpoints through a standardized Model Context Protocol interface. It provides tools for efficient async handling and seamless integration of USDC functionalities into automated workflows.

GoHighLevel MCP Server

Connects Claude Desktop directly to GoHighLevel CRM accounts with 269+ tools across contacts, messaging, opportunities, calendars, marketing automation, e-commerce, and business operations management.