Discover Awesome MCP Servers

Ocean.io MCP Server

A Model Context Protocol server that enables finding lookalike companies based on seed companies through integration with the Ocean.io API.

Todoist MCP Server

An MCP server that connects Claude with Todoist for complete task and project management through natural language.

Cloudflare Playwright MCP

An MCP server that enables AI assistants to perform web automation tasks like navigation, typing, and clicking using Playwright on Cloudflare Workers. It allows models to interact with websites and capture screenshots directly through a set of integrated browser tools.

Figma MCP Server

Jembatan antara desain Figma dan implementasi React yang memungkinkan konversi desain Figma menjadi aplikasi React dengan sempurna (pixel-perfect) dengan memproses data file Figma ke dalam format yang mudah digunakan oleh React.

REMnux MCP Server

Enables AI assistants to execute malware analysis tools on a REMnux system via Docker, SSH, or local connections. It provides automated file-type analysis, structured tool discovery, and security guardrails for streamlined malware investigation.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK. Includes example tools for calculations and greetings, plus system information resources.

remi

Apple Reminders CLI and MCP server with section support and iCloud sync — the only tool that can create, manage, and sync sections across devices

Claude Desktop Config Manager

Sebuah alat baris perintah ringan untuk mengelola konfigurasi Claude Desktop MCP (Model Context Protocol). Alat ini memudahkan untuk mengaktifkan dan menonaktifkan server MCP, membuat konfigurasi preset, dan mengelola cadangan.

Facebook Scraper3 MCP Server

Enables access to the Facebook Scraper3 API to extract data from Facebook profiles, pages, groups, and the marketplace. It provides comprehensive tools for searching posts, people, and events, as well as retrieving detailed metadata for comments, reactions, and media.

Filesystem Watcher MCP

Enables AI coding agents to watch directories for live filesystem changes (create, modify, delete, move) via the Model Context Protocol, providing event-driven access without busy-polling.

BLS (Bureau of Labor Statistics) MCP Server

Provides access to U.S. labor market data including employment statistics, Consumer Price Index inflation rates, and wage information. Users can query specific time series data or use shortcuts for common economic indicators like unemployment and industry-specific employment.

ABAP-ADT-API MCP-Server

An MCP server that facilitates seamless interaction with SAP ABAP systems to manage development objects, transport requests, and source code. It provides a comprehensive suite of tools for performing syntax checks, object searches, and code modifications via the ADT API.

MCP Adobe Premiere Pro

An AI-powered automation bridge for Adobe Premiere Pro that enables controlling video edits with natural language and automating workflows through Claude or other AI agents.

Gmail MCP Server

A comprehensive MCP server providing 24 tools for full Gmail management, including email operations, label organization, and batch filtering. It features multi-account support and secure OAuth authentication for interacting with mailboxes via natural language.

ChromaDB Local MCP Server

Provides AI assistants with persistent memory through local ChromaDB vector storage, featuring automated file ingestion and batch processing for over 70 file types. It enables advanced vector search, EXIF metadata extraction for photos, and duplicate file detection across local directories.

MCP Research Server

Provides tools for automated company research, competitor identification, and business model analysis to generate comprehensive business intelligence. It enables users to extract market keywords and synthesize competitive insights via AI-powered research capabilities.

cocos-mcp

A headless MCP server that enables AI to create complete 2D/3D games in Cocos Creator without opening the editor or writing TypeScript code, featuring 184 tools for scene building, physics, UI, and automated testing.

MCP Study Agent

An MCP server that enables users to interact with local documents for educational purposes through tools for listing and reading files. It features an integrated agent capable of automatically generating document summaries and study flashcards.

Fetch TypeScript Server

Sebuah server Protokol Konteks Model yang menyediakan kemampuan pengambilan dan konversi konten web.

mcp-mgccli

Exposes 7 read-only MCP tools for Magalu Cloud products (block storage, virtual machines, Kubernetes, etc.) using authenticated mgc CLI commands, enabling natural language queries about cloud resources.

Learning Assistant Server

Server MCP untuk menganalisis PDF dan merekomendasikan soal-soal latihan

MCP-Undetected-Chromedriver

An MCP service that automates Chrome browser control while bypassing anti-bot detection mechanisms, enabling web scraping, testing and automation on sites with sophisticated bot protection.

MCP4Amazon

An MCP server that enables large language models to directly access and analyze Amazon product information, including product details, variants, and reviews.

MCP Heuristics - Garden Management System

Here are a few options for a Proof of Concept (POC) for tracking MCP (presumably Minecraft Protocol) server tool usage with Kestra, along with considerations for each: **Option 1: Simple Log Parsing and Aggregation** * **Concept:** Parse the logs generated by your MCP server tools to extract usage information (e.g., which tools were used, when, by whom). Aggregate this data and store it in a database or file. Use Kestra to automate the log parsing, aggregation, and storage process. * **Kestra Flow:** 1. **Trigger:** A `Schedule` trigger to run the flow periodically (e.g., hourly, daily). 2. **Task 1: Fetch Logs:** Use a `io.kestra.plugin.fs.v2.List` task to list log files in the directory where your MCP server tools write logs. You might need to filter by date or filename pattern. 3. **Task 2: Read Logs:** Use a `io.kestra.plugin.fs.v2.Read` task to read the content of each log file. You'll likely need to iterate over the files found in Task 1 using a `Each` task. 4. **Task 3: Parse Logs:** This is the core of the POC. Use a `io.kestra.plugin.scripts.shell.Commands` task with a script (e.g., Python, Bash, or even a Kestra `Transform` task with Jinja templating) to: * Parse the log lines. Use regular expressions or a more structured parsing library (if your logs are in a structured format like JSON). * Extract relevant information (tool name, timestamp, user, arguments, etc.). * Format the extracted data into a structured format (e.g., CSV, JSON). 5. **Task 4: Aggregate Data:** Use another `io.kestra.plugin.scripts.shell.Commands` task to aggregate the parsed data. This could involve counting tool usage, calculating average execution times, etc. The aggregation logic depends on what you want to track. 6. **Task 5: Store Data:** Use a task to store the aggregated data. Options include: * `io.kestra.plugin.jdbc.JdbcQuery` to insert data into a database (e.g., PostgreSQL, MySQL). * `io.kestra.plugin.fs.v2.Write` to write the data to a file (e.g., CSV, JSON) in a cloud storage bucket (e.g., AWS S3, Google Cloud Storage). * `io.kestra.plugin.elasticsearch.Index` to index the data in Elasticsearch for searching and analysis. * **Pros:** * Relatively simple to implement. * Leverages existing log data. * Good starting point for understanding Kestra. * **Cons:** * Relies on log format, which might be inconsistent or change over time. * Parsing can be complex if logs are unstructured. * May not capture all usage information if the tools don't log everything. **Option 2: Instrumenting the MCP Server Tools** * **Concept:** Modify the MCP server tools to directly report usage information to a central service. This provides more accurate and reliable data than log parsing. * **Kestra Flow:** 1. **Trigger:** Not directly involved in the data collection. The trigger would be for reporting or analysis. 2. **Data Collection:** The MCP server tools would need to be modified to send data to an API endpoint. This could be a simple HTTP endpoint that accepts JSON payloads. You could use a lightweight framework like Flask (Python) or Express.js (Node.js) to create the API. 3. **Task 1: (Optional) Data Transformation:** If the data needs to be transformed before storage, you can use a `io.kestra.plugin.scripts.shell.Commands` task or a `Transform` task. 4. **Task 2: Store Data:** Similar to Option 1, use a task to store the data in a database, file, or Elasticsearch. 5. **Task 3: Reporting/Analysis:** Use Kestra to run reports or analyses on the stored data. This could involve querying the database, processing the data with Python scripts, and generating visualizations. * **Pros:** * More accurate and reliable data. * Can capture more detailed usage information. * Less dependent on log format. * **Cons:** * Requires modifying the MCP server tools, which might be difficult or impossible if you don't have access to the source code. * Adds complexity to the MCP server tools. * Requires setting up and maintaining an API endpoint. **Option 3: Proxying MCP Server Tool Calls** * **Concept:** Instead of directly calling the MCP server tools, users call a proxy service that logs the usage and then forwards the call to the actual tool. * **Kestra Flow:** 1. **Trigger:** Not directly involved in the data collection. The trigger would be for reporting or analysis. 2. **Proxy Service:** Create a proxy service (e.g., using Python, Node.js, or Go) that: * Receives the request from the user. * Logs the request details (tool name, arguments, user, timestamp). * Forwards the request to the actual MCP server tool. * Returns the response to the user. 3. **Data Collection:** The proxy service would need to store the logged data. This could be done directly to a database or by sending the data to an API endpoint. 4. **Task 1: (Optional) Data Transformation:** If the data needs to be transformed before storage, you can use a `io.kestra.plugin.scripts.shell.Commands` task or a `Transform` task. 5. **Task 2: Store Data:** Similar to Option 1, use a task to store the data in a database, file, or Elasticsearch. 6. **Task 3: Reporting/Analysis:** Use Kestra to run reports or analyses on the stored data. This could involve querying the database, processing the data with Python scripts, and generating visualizations. * **Pros:** * Doesn't require modifying the MCP server tools directly. * Provides more control over the data collection process. * Can capture more detailed usage information. * **Cons:** * Requires setting up and maintaining a proxy service. * Adds latency to the MCP server tool calls. * May require changes to how users interact with the tools. **Recommendation for a POC:** Start with **Option 1 (Simple Log Parsing and Aggregation)**. It's the easiest to implement and will give you a good understanding of how Kestra works. If the log data is insufficient or unreliable, consider moving to Option 2 or 3. **Key Considerations for Your POC:** * **Log Format:** Understand the format of your MCP server tool logs. Are they structured (e.g., JSON) or unstructured? This will determine the complexity of the parsing logic. * **Data to Track:** Decide what usage information you want to track. This will influence the parsing logic and the aggregation logic. * **Storage:** Choose a storage solution that is appropriate for your needs. A database is a good choice for structured data, while a file storage service is suitable for unstructured data. * **Security:** Consider security implications, especially if you are storing sensitive data. * **Scalability:** Think about how the solution will scale as your usage grows. **Example Kestra Flow (Option 1 - Simplified):** This is a very basic example to get you started. You'll need to adapt it to your specific needs. ```yaml id: mcp_tool_usage_tracking namespace: your.namespace tasks: - id: list_logs type: io.kestra.plugin.fs.v2.List path: /path/to/mcp/logs pattern: "mcp_tool_*.log" - id: read_logs type: io.kestra.plugin.fs.v2.Read inputFiles: "{{ outputs.list_logs.files }}" defaults: type: io.kestra.core.tasks.flows.Each tasks: - id: parse_log type: io.kestra.plugin.scripts.shell.Commands commands: - | #!/bin/bash # Example parsing using grep and awk (replace with your actual parsing logic) cat {{ taskrun.value }} | grep "Tool Used:" | awk '{print $3}' > /tmp/tool_usage.txt cat /tmp/tool_usage.txt | sort | uniq -c outputFiles: - /tmp/tool_usage.txt - id: store_usage type: io.kestra.plugin.fs.v2.Write from: "{{ outputs['parse_log'].files['/tmp/tool_usage.txt'] }}" path: s3://your-bucket/mcp_tool_usage/{{ execution.id }}/tool_usage.txt triggers: - id: daily_run type: io.kestra.core.models.triggers.types.Schedule schedule: "0 0 * * *" # Run daily at midnight ``` **Explanation:** 1. **`list_logs`:** Lists all files matching the pattern `mcp_tool_*.log` in the `/path/to/mcp/logs` directory. Replace this with your actual log directory and filename pattern. 2. **`read_logs`:** Reads the content of each log file found by `list_logs`. The `inputFiles` parameter uses the output of the `list_logs` task. The `defaults` section uses an `Each` task to iterate over the files. 3. **`parse_log`:** This is a `Commands` task that executes a Bash script. **This is where you'll need to write your actual log parsing logic.** The example script uses `grep` and `awk` to extract the tool name from log lines that contain "Tool Used:". It then counts the occurrences of each tool. The output is written to `/tmp/tool_usage.txt`. **Replace this with your specific parsing logic.** 4. **`store_usage`:** Writes the content of `/tmp/tool_usage.txt` to an S3 bucket. Replace `s3://your-bucket/mcp_tool_usage/{{ execution.id }}/tool_usage.txt` with your desired S3 path. 5. **`daily_run`:** A `Schedule` trigger that runs the flow daily at midnight. **Next Steps:** 1. Install Kestra. 2. Create a Kestra flow based on the example above. 3. Adapt the `parse_log` task to your specific log format and data requirements. 4. Test the flow and verify that it is extracting the correct information. 5. Refine the flow and add more features as needed. Remember to consult the Kestra documentation for more information on the available tasks and features: [https://kestra.io/docs](https://kestra.io/docs) Good luck with your POC!

geotap-mcp-server

ollect comprehensive environmental data from 80+ US federal sources (FEMA, EPA, USGS, NOAA, NRCS, USFWS, DOE, DOT, CDC, Census) for any US location. One tool returns flood zones, soils, wetlands, rainfall, water quality, contamination, seismic risk, infrastructure, ecology, energy, and demographics.

MCP Rust/Slint Development Server

Provides up-to-date information for Rust and Slint development by fetching real-time data from GitHub repositories, including package search, UI components, release news, and development resources with automatic caching and refresh capabilities.

mcp-server-ascom

Control telescopes, cameras, and focusers with AI through natural language, using any ASCOM Alpaca device.

mcp-rfc-editor

An MCP server for creating, loading, and editing RFC TXT documents using the rfc-editor Python library. It provides a suite of tools to manage document components including sections, abstracts, titles, and author metadata.

Mindpilot MCP

Visualize anything from Claude Code as a mermaid diagram in a locally hosted web app.

Wine Tasting Visual Vocabulary MCP Server

Translates wine tasting vocabulary (varietal, terroir, balance, aging) into visual parameters for AI image generation, enabling sommeliers to describe wines in their native sensory language and get corresponding visual attributes for creating wine-inspired imagery.