Discover Awesome MCP Servers

Jira Prompts MCP Server

Un servidor MCP que ofrece varios comandos para generar prompts o contextos a partir del contenido de Jira.

Knowledge Graph Memory Server

Una implementación mejorada de memoria persistente que utiliza un grafo de conocimiento local con una opción `--memory-path` personalizable. Esto permite que Claude recuerde información sobre el usuario entre chats.

NEXUS Memory MCP App

A sovereign, six-layer permanent memory system that provides users with a structured and persistent personal knowledge base across VS Code, Claude, and ChatGPT. It utilizes a neural mesh architecture and ENGRAM O(1) lookup to ensure data ownership and constant-time memory retrieval.

TermPipe MCP

Provides AI assistants with direct terminal access to execute commands, manage files, and run persistent REPL sessions. It features automated installation scripts that educate AI assistants on its capabilities for seamless integration.

macOS Tools MCP Server

Provides read-only access to native macOS system utilities including disk management, battery status, network configuration, and system profiling through terminal commands. Enables users to retrieve system information and diagnostics from macOS machines via standardized MCP tools.

Datastream MCP Server

A Multi-Agent Conversation Protocol server that enables interaction with Google Cloud Datastream API for managing data replication services between various source and destination systems through natural language commands.

MCP Sample Server

A simple Model Context Protocol server providing basic utility tools including timezone-aware time retrieval and basic arithmetic calculations (add, subtract, multiply, divide).

Web Crawler MCP Server

An intelligent web crawling server that uses Cloudflare's headless browser to render dynamic pages and Workers AI to extract relevant links based on natural language queries. It enables AI assistants to search and filter website content while providing secure access through GitHub OAuth authentication.

Advanced MCP Server

A comprehensive Model Context Protocol server providing capabilities for web scraping, data analysis, system monitoring, file operations, API integrations, and report generation.

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.

play-sound-mcp-server

An MCP server that plays local sound files on macOS using the afplay command, allowing AI assistants to trigger audio notifications after responding.

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.

Owlvin MCP Server

Enables AI agents to access a wide range of AI tools and services through the Owlvin platform with a single integration. It manages authentication and billing automatically, allowing users to list available services, check credit balances, and execute specialized API calls.

Screen Agent

A Windows desktop automation MCP server that enables UI recognition through OCR, UIA controls, and multi-point color matching. It allows agents to interact with desktop applications via actions like clicking and typing while using a learning system to track and improve operation success.

browser-mcp

Un servidor MCP que permite a los asistentes de IA interactuar con el navegador, incluyendo la obtención del contenido de la página como markdown, la modificación de los estilos de la página y la búsqueda en el historial del navegador.

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.

tldraw MCP

Enables AI agents to read, write, and search local tldraw (.tldr) files, providing a persistent visual scratchpad for diagramming and note organization. It supports full CRUD operations on canvas shapes and metadata management for local canvas files.

Dummy MCP Server

A simple Meta-agent Communication Protocol server built with FastMCP framework that provides 'echo' and 'dummy' tools via Server-Sent Events for demonstration and testing purposes.

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.

ffmpeg-mcp

Enables comprehensive video and audio processing using FFmpeg, supporting tasks like metadata extraction, clipping, scaling, and adding transitions or overlays. It provides a high-performance interface for building media processing microservices via FastMCP.

MCP Servers

Una colección de servidores MCP (Protocolo de Contexto de Modelo) como herramientas de dotnet.

HashiCorp Vault MCP Server

Enables interaction with HashiCorp Vault for secret management operations including reading, writing, listing, and deleting secrets through the Model Context Protocol.

Google Search MCP Server

Una implementación de servidor MCP que se integra con la API JSON de Búsqueda Personalizada de Google, proporcionando capacidades de búsqueda 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 Flutter project idea that leverages the Flutter CLI and a hypothetical "MCP (Model Context Protocol) Server" for a more dynamic and data-driven development experience. I'll outline the project, explain how the MCP Server *could* be used, and provide some example Flutter CLI commands. **Project Idea: "Dynamic Recipe App"** This app will display recipes fetched from a hypothetical MCP Server. The MCP Server will allow you to easily update the recipes without needing to redeploy the Flutter app. Think of it as a lightweight CMS specifically designed to feed data to your Flutter app. **Core Features:** * **Recipe Listing:** Displays a list of recipe titles and brief descriptions. * **Recipe Detail View:** Shows the full recipe, including ingredients, instructions, and potentially images. * **Dynamic Updates:** The app automatically reflects changes made to the recipes on the MCP Server (e.g., new recipes, updated ingredients). * **Search/Filtering (Optional):** Allow users to search for recipes by name or filter by ingredients. * **User Ratings/Reviews (Optional):** Allow users to rate and review recipes. **How the Hypothetical MCP Server Would Work (Conceptual):** The MCP Server would expose an API (likely REST or GraphQL) that allows you to: * **Define Data Models:** Specify the structure of a recipe (e.g., title, description, ingredients, instructions, image URL). * **Manage Data:** Create, read, update, and delete recipes. * **Provide Data Context:** The server would provide the data in a structured format that the Flutter app can easily consume. This is where the "Context" part of MCP comes in. It provides the data *and* the metadata about the data. **Flutter CLI Commands (Example):** 1. **Create a New Flutter Project:** ```bash flutter create dynamic_recipe_app cd dynamic_recipe_app ``` 2. **Add Dependencies:** You'll need `http` for making API requests and potentially `cached_network_image` for efficient image loading. You might also want a state management solution like Provider, Riverpod, or BLoC. ```bash flutter pub add http flutter pub add cached_network_image flutter pub add provider # Or your preferred state management ``` 3. **Generate Initial UI (Using Flutter CLI - Hypothetical MCP Integration):** *This is where the MCP integration would be really cool. Imagine a command that could scaffold basic UI elements based on the data model defined on the MCP Server.* ```bash # Hypothetical command: flutter mcp generate ui --model recipe --output lib/screens/recipe_list.dart flutter mcp generate ui --model recipe --output lib/screens/recipe_detail.dart --detail ``` * This command *doesn't exist* in the standard Flutter CLI. It's an example of how the CLI *could* be extended to work with an MCP Server. It would generate basic Flutter code for displaying a list of recipes and a detailed view of a single recipe, based on the `recipe` model defined on the MCP Server. 4. **Run the App:** ```bash flutter run ``` **Flutter Code Structure (Example - Without Hypothetical CLI):** Since the `flutter mcp generate ui` command is hypothetical, you'll need to write the UI code manually. Here's a basic structure: * `lib/main.dart`: The entry point of your app. Sets up the MaterialApp and initial route. * `lib/models/recipe.dart`: Defines the `Recipe` class (e.g., `title`, `description`, `ingredients`, `instructions`, `imageUrl`). * `lib/screens/recipe_list.dart`: Fetches the list of recipes from the MCP Server and displays them in a `ListView`. * `lib/screens/recipe_detail.dart`: Displays the details of a single recipe. * `lib/services/api_service.dart`: Handles the HTTP requests to the MCP Server. This class would have methods like `getRecipes()` and `getRecipe(int id)`. * `lib/widgets/recipe_card.dart`: A reusable widget to display a recipe in the list. **Example `lib/services/api_service.dart` (Illustrative):** ```dart import 'dart:convert'; import 'package:http/http.dart' as http; import 'package:dynamic_recipe_app/models/recipe.dart'; // Assuming you have a Recipe model class ApiService { final String baseUrl = 'YOUR_MCP_SERVER_URL'; // Replace with your MCP server URL Future<List<Recipe>> getRecipes() async { final response = await http.get(Uri.parse('$baseUrl/recipes')); if (response.statusCode == 200) { List<dynamic> body = jsonDecode(response.body); List<Recipe> recipes = body.map((dynamic item) => Recipe.fromJson(item)).toList(); return recipes; } else { throw Exception('Failed to load recipes'); } } Future<Recipe> getRecipe(int id) async { final response = await http.get(Uri.parse('$baseUrl/recipes/$id')); if (response.statusCode == 200) { Map<String, dynamic> body = jsonDecode(response.body); Recipe recipe = Recipe.fromJson(body); return recipe; } else { throw Exception('Failed to load recipe'); } } } ``` **Key Considerations:** * **State Management:** Choose a state management solution (Provider, Riverpod, BLoC) to handle the data flow and updates in your app. This is crucial for reflecting changes from the MCP Server. * **Error Handling:** Implement proper error handling for API requests. * **Loading Indicators:** Show loading indicators while data is being fetched from the MCP Server. * **Real-time Updates (Optional):** For true real-time updates, you could explore using WebSockets or Server-Sent Events (SSE) with your MCP Server. This would allow the server to push updates to the app whenever a recipe is changed. * **Security:** If your MCP Server requires authentication, implement appropriate authentication mechanisms in your Flutter app. **Why This is a Fun Project:** * **Dynamic Content:** You can update the app's content without redeploying the app. * **Backend Integration:** It involves integrating with a backend API, which is a common task in real-world app development. * **Scalability:** The MCP Server concept allows you to easily scale the content of your app. * **Learning Opportunity:** You'll learn about HTTP requests, JSON parsing, state management, and potentially real-time communication. * **Hypothetical CLI Extension:** Thinking about how the Flutter CLI could be extended to work with an MCP Server is a great exercise in understanding the Flutter ecosystem and potential future improvements. **To make this project real, you would need to:** 1. **Build the MCP Server:** This is the most significant part. You could use Node.js with Express, Python with Flask or Django, or any other backend technology you're comfortable with. The server needs to expose an API for managing recipes. 2. **Implement the Flutter App:** Write the Flutter code to fetch data from the MCP Server and display it in the UI. This project provides a solid foundation for building a dynamic and data-driven Flutter application. Remember to replace `YOUR_MCP_SERVER_URL` with the actual URL of your MCP server. Good luck!

mcp-lucene-server

mcp-lucene-server

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.

LiblibAI Picture Generator

Enables AI image generation through LiblibAI API with natural language prompts. Supports various art styles, real-time progress tracking, and account credit management.

Integrator MCP Server

A Model Context Protocol server that allows AI assistants to invoke and interact with Integrator automation workflows through an API connection.