Discover Awesome MCP Servers

mcp-taskwarrior-ai

An AI-native Taskwarrior bridge that provides natural language task management for Claude Code and other AI systems, integrating with existing Taskwarrior infrastructure.

MCP Docs Server

Aggregates documentation from multiple sources (llms.txt format or web scraping) and provides semantic search capabilities using vector embeddings and hybrid search for each documentation source.

automatised-pipeline

A Rust MCP server that indexes codebases into a property graph and provides tools for code intelligence, such as searching, context, impact analysis, and change detection.

@webability/mcp

An MCP server for web accessibility testing that enables scanning, auditing, and fixing WCAG, ADA, and other compliance issues directly from your IDE, with free local scans, AI-generated framework-aware fixes, and verification capabilities.

mcp-instagram-dm

MCP server for Instagram Direct Messages. Read inbox, send messages, search conversations, react to messages, manage pending requests, and more. 15 tools with cookie-based authentication.

Cloudflare Playwright MCP

Enables AI assistants to perform web automation tasks such as navigation, typing, clicking, and taking screenshots using Playwright on Cloudflare Workers. This server allows LLMs to interact with and control a browser across platforms like Claude Desktop and GitHub Copilot.

vibops-mcp

VibOps MCP is the control plane between your AI agents and your GPU infrastructure. 74 tools covering: GPU fleet management (deploy, scale, monitor across NVIDIA, AMD, Intel, AWS, Google, Groq), Agent Infrastructure Control Plane (per-agent GPU cost, budget enforcement, model policies, dependency graph), governance (AI Act, SOC 2, immutable HMAC audit chain), and GPU FinOps (chargeback, waste..)..

kra-mcp

Enables Kenya tax compliance through MCP tools for PAYE, VAT, PIN registration, and tax incentives.

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.

mcp-emtrafesa

Enables AI assistants to access Emtrafesa bus transportation services in Peru, including querying terminals, schedules, tickets, and FAQs.

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.

HomeBox Edge

Serverless HomeBox-compatible family asset ledger with MCP tools for creating, searching, updating, archiving assets, and importing/exporting CSV/TSV.

jsx-notation

Compresses React/Next.js files, HTML, and SVG into a compact JSXN notation optimized for AI assistants, reducing token consumption by ~40%. Provides an MCP server with tools to read, encode, and decode JSXN.

docs-cache-mcp

A local MCP server that fetches official library documentation (llms.txt-first), caches it to disk, and serves relevant sections to coding agents offline with deterministic retrieval.

question-market

MCP server for question.market prediction markets on Algorand. Enables market browsing, wallet onboarding, and trading through natural language.

XRootD MCP Server

An MCP server providing access to XRootD file systems, allowing LLMs to browse directories, read file metadata, and access contents via the root:// protocol. It supports advanced features like campaign discovery, file searching, and ROOT file analysis for scientific data management.

MacroMCP

Remote MCP server for natural-language calorie/macro and weight tracking, designed to connect to Claude.ai as a custom connector.

playcaller

An MCP server that enables AI agents to play-test Unity games by capturing screenshots and simulating inputs like taps, drags, and key presses, acting as a Playwright for Unity.

GraphSense MCP Server

Enables natural language queries about JavaScript/TypeScript codebases using graph and vector search. Allows finding functions by semantic description, callers, callees, and function details.

vision-mcp

Vision MCP enables text-only agents to understand images through any OpenAI-compatible vision model. It supports local images, URLs, screenshots, documents, charts, and code errors with tools like analyze_image and understand_image.

quantum-demos-mcp

MCP server for authoring Quantum customer demos from Claude Code; enables listing, viewing, and updating demos with a guide and prompts.

Jira Data Center MCP Server

Enables AI assistants to deeply introspect Jira Data Center configurations — including workflows, schemes, automation, and Assets — through 76 read-only tools, without any modification capability.

Google Workspace MCP Server

Enables AI agents to send emails and append content to Google Docs using Gmail and Google Docs APIs.

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.

Brosh Browser Screenshot

Captures comprehensive webpage screenshots with intelligent scrolling, text extraction, and HTML analysis, enabling AI tools to visually inspect and understand web content through the Model Context Protocol.

AI-Scholarly-Mode

Enables AI assistants to search and retrieve peer-reviewed academic articles exclusively from Springer Nature's open access collection. It provides a specialized mode for research-driven conversations, allowing users to toggle scholarly-only search and fetch full article content.

logseq-api-mcp

AI assistant integration with Logseq knowledge graph: 21 tools to read, write, query, and search notes, enabling seamless interaction with your notes.

directa-mcp

MCP server that connects Claude to Directa's Darwin trading API, enabling local account management, portfolio views, and order operations through natural language.

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.