Discover Awesome MCP Servers

Tavily Search

Implementasi server MCP yang mengintegrasikan Tavily Search API, menyediakan kemampuan pencarian yang dioptimalkan untuk LLM.

Simple MCP Server with upstream auth via local rest endpoint

Kotak pasir untuk membuat prototipe server MCP.

k8s-pilot

A lightweight, centralized control plane server that enables management of multiple Kubernetes clusters simultaneously, supporting context switching and CRUD operations on common Kubernetes resources.

mcp-remote-py

A minimal Python-based proxy that bridges local MCP STDIO clients with remote MCP SSE servers. It enables bidirectional JSON-RPC message passing between standard command-line tools and web-based remote endpoints.

astro-airflow-mcp

An MCP server that enables AI assistants to interact with Apache Airflow's REST API for DAG management, task monitoring, and system diagnostics. It provides comprehensive tools for triggering workflows, retrieving logs, and inspecting system health across Airflow 2.x and 3.x versions.

Twilio MCP

Enables sending SMS text messages through Twilio's messaging service with a simple send_text tool that supports configurable recipients and messaging service integration.

Mcp Cassandra Server

Berikut adalah terjemahan dari "Model Context Protocol for Cassandra database" ke dalam Bahasa Indonesia: **Protokol Konteks Model untuk basis data Cassandra** Atau, bisa juga: **Protokol Konteks Model untuk database Cassandra** Kedua terjemahan tersebut memiliki arti yang sama dan dapat digunakan. Pilihan mana yang lebih baik tergantung pada preferensi pribadi dan konteks penggunaannya.

NervusDB MCP Server

Enables building and querying code knowledge graphs for project analysis, with tools for exploring code relationships, managing workflows, and automating development tasks. Integrates with Git and GitHub for branch management and pull request creation.

MCP Server Boilerplate

A starter template for building Model Context Protocol servers that can integrate with AI assistants like Claude or Cursor, providing custom tools, resource providers, and prompt templates.

sheet-music-mcp

Sebuah Server MCP untuk rendering partitur musik

MCP 만들면서 원리 파헤쳐보기

Okay, here's a breakdown of the server and client implementation for a system conceptually similar to the MCP (Master Control Program) from the movie Tron, but adapted for modern computing. Keep in mind that a real-world MCP would be incredibly complex, so this is a simplified, illustrative example. **Important Considerations Before We Start:** * **Security:** In the Tron universe, the MCP had near-total control. In a real-world system, security is paramount. Any "MCP-like" system should have robust authentication, authorization, and auditing mechanisms to prevent abuse and unauthorized access. * **Abstraction:** The MCP in Tron was a monolithic entity. Modern systems favor modularity and microservices. Think of this as a *distributed* MCP, where different components handle specific tasks. * **Purpose:** What is the *actual* goal of this system? Is it resource management, task scheduling, security enforcement, or something else? The design will heavily depend on the intended purpose. * **Technology Stack:** The choice of programming languages, frameworks, and databases will influence the implementation. I'll provide examples using common technologies like Python (with Flask or FastAPI for the server) and potentially JavaScript (for a web-based client). **Conceptual Architecture** Let's imagine a simplified scenario where the "MCP" is responsible for: 1. **Resource Allocation:** Managing CPU, memory, and network bandwidth for different applications. 2. **Task Scheduling:** Prioritizing and scheduling tasks to optimize system performance. 3. **Monitoring:** Tracking system health and performance metrics. **Server-Side (The "MCP" Core)** * **Language:** Python (Flask or FastAPI) * **Components:** * **API Endpoint (Flask/FastAPI):** Provides a RESTful API for clients to interact with the MCP. Examples: * `/allocate_resource`: Requests resource allocation. * `/submit_task`: Submits a task for scheduling. * `/get_status`: Retrieves system status and resource usage. * `/authenticate`: Handles client authentication. * **Resource Manager:** Tracks available resources and allocates them to applications based on policies. This might involve interacting with the operating system's resource management APIs (e.g., `psutil` in Python). * **Task Scheduler:** Implements a scheduling algorithm (e.g., priority-based, round-robin) to determine the order in which tasks are executed. Could use a task queue like Celery or Redis Queue for asynchronous task processing. * **Monitoring Module:** Collects system metrics (CPU usage, memory usage, network traffic) using tools like `psutil` or system monitoring daemons. Stores the data in a time-series database (e.g., Prometheus, InfluxDB) for analysis and visualization. * **Authentication/Authorization Module:** Handles user authentication (verifying identity) and authorization (determining what actions a user is allowed to perform). Could use libraries like `Flask-Login` or `Authlib` for authentication and role-based access control (RBAC). * **Database (Optional):** Stores configuration data, user accounts, resource allocation information, and task history. Could use a relational database (e.g., PostgreSQL, MySQL) or a NoSQL database (e.g., MongoDB). **Example (Flask - Simplified Resource Allocation Endpoint):** ```python from flask import Flask, request, jsonify import psutil # For system monitoring app = Flask(__name__) # In-memory resource pool (replace with a more robust solution) resource_pool = { "cpu": 8, # Example: 8 CPU cores "memory": 16 * 1024 * 1024 * 1024 # Example: 16 GB of memory (in bytes) } @app.route('/allocate_resource', methods=['POST']) def allocate_resource(): data = request.get_json() resource_type = data.get('resource_type') amount = data.get('amount') if resource_type not in resource_pool: return jsonify({'error': 'Invalid resource type'}), 400 if resource_pool[resource_type] < amount: return jsonify({'error': 'Insufficient resources'}), 400 resource_pool[resource_type] -= amount return jsonify({'message': f'Allocated {amount} of {resource_type}'}), 200 @app.route('/get_status', methods=['GET']) def get_status(): cpu_usage = psutil.cpu_percent(interval=1) memory_usage = psutil.virtual_memory().percent return jsonify({ 'cpu_usage': cpu_usage, 'memory_usage': memory_usage, 'available_cpu': resource_pool['cpu'], 'available_memory': resource_pool['memory'] }) if __name__ == '__main__': app.run(debug=True) ``` **Client-Side** * **Language:** Python (for command-line tools) or JavaScript (for a web-based interface) * **Components:** * **Command-Line Interface (CLI):** A tool that allows users to interact with the MCP from the command line. Uses the `requests` library in Python to make API calls to the server. * **Web Interface (HTML/CSS/JavaScript):** A graphical user interface (GUI) that provides a more user-friendly way to interact with the MCP. Uses JavaScript to make API calls to the server (using `fetch` or `axios`). * **Authentication:** Handles user login and authentication with the MCP server. Stores authentication tokens securely (e.g., using cookies or local storage). * **Data Visualization:** Displays system status, resource usage, and task information in a clear and informative way (e.g., using charts and graphs). Libraries like Chart.js or D3.js can be used for data visualization. **Example (Python CLI Client):** ```python import requests import json SERVER_URL = "http://127.0.0.1:5000" # Replace with your server URL def allocate_resource(resource_type, amount): url = f"{SERVER_URL}/allocate_resource" data = {'resource_type': resource_type, 'amount': amount} headers = {'Content-type': 'application/json'} response = requests.post(url, data=json.dumps(data), headers=headers) if response.status_code == 200: print(response.json()['message']) else: print(f"Error: {response.status_code} - {response.json().get('error', 'Unknown error')}") def get_status(): url = f"{SERVER_URL}/get_status" response = requests.get(url) if response.status_code == 200: status = response.json() print("System Status:") print(f" CPU Usage: {status['cpu_usage']}%") print(f" Memory Usage: {status['memory_usage']}%") print(f" Available CPU: {status['available_cpu']}") print(f" Available Memory: {status['available_memory']}") else: print(f"Error: {response.status_code} - {response.json().get('error', 'Unknown error')}") if __name__ == '__main__': while True: print("\nChoose an action:") print("1. Allocate Resource") print("2. Get Status") print("3. Exit") choice = input("Enter your choice: ") if choice == '1': resource_type = input("Enter resource type (cpu/memory): ") amount = int(input("Enter amount to allocate: ")) allocate_resource(resource_type, amount) elif choice == '2': get_status() elif choice == '3': break else: print("Invalid choice.") ``` **Key Implementation Details:** * **API Design:** Use RESTful principles for the API. Define clear endpoints for each operation (resource allocation, task submission, status retrieval). Use JSON for data exchange. * **Resource Management:** Implement a robust resource management system that tracks available resources and allocates them to applications based on policies. Consider using a resource reservation system to guarantee resources for critical tasks. * **Task Scheduling:** Choose a scheduling algorithm that meets the needs of your system. Consider using a task queue to handle asynchronous task processing. * **Monitoring:** Collect system metrics and store them in a time-series database. Use data visualization tools to display the data in a clear and informative way. * **Security:** Implement robust authentication and authorization mechanisms to prevent unauthorized access. Use encryption to protect sensitive data. Regularly audit the system for security vulnerabilities. * **Error Handling:** Implement proper error handling to gracefully handle unexpected situations. Log errors to a file or database for debugging purposes. * **Scalability:** Design the system to be scalable to handle increasing workloads. Consider using a distributed architecture to distribute the load across multiple servers. **Further Enhancements (Tron-Inspired):** * **Visualization:** Create a 3D visualization of the system's resources and tasks, similar to the Tron grid. Use a graphics library like Three.js or Babylon.js. * **AI/Machine Learning:** Use AI/ML to optimize resource allocation and task scheduling. Train a model to predict resource usage and adjust allocation accordingly. * **Security Protocols:** Implement advanced security protocols that resemble the challenges faced in the Tron universe, such as identity verification and intrusion detection. **Important Considerations for a Real-World "MCP":** * **Operating System Integration:** A true MCP would need deep integration with the operating system to control resources and processes effectively. This would likely require kernel-level programming. * **Hardware Abstraction:** The MCP should be able to manage resources across different types of hardware. This would require a hardware abstraction layer. * **Policy Enforcement:** The MCP should be able to enforce policies related to resource usage, security, and compliance. * **Auditing:** The MCP should log all actions taken, including resource allocations, task submissions, and security events. This is essential for auditing and compliance purposes. This is a high-level overview. The specific implementation details will depend on the specific requirements of your system. Remember to prioritize security, modularity, and scalability when designing your "MCP." Good luck!

Simple Voice MCP Server

Enables text-to-speech playback with multiple Japanese character voices using VLC, supporting simultaneous audio playback and custom pronunciation dictionaries for English words.

rust-faf-mcp RMCP

Persistent project context in Rust. 8 MCP tools via rmcp SDK — parse, validate, score, compress, discover, and token analysis. Single binary, zero config. IANA-registered format (application/vnd.faf+yaml). One file, every AI platform.

OpenAccess MCP

Enables secure remote access operations through SSH, SFTP, rsync, VPN, and tunneling with enterprise-grade policy enforcement and audit logging. Provides AI assistants with secure, policy-driven access to remote systems while maintaining comprehensive audit trails and zero-trust security.

TreeBeam MCP Server

Enables AI assistants to interact with the TreeBeam financial management and accounting platform. Users can list organizations and projects using secure OAuth 2.0 authentication integrated directly into their AI conversation.

custom_mcp_server

Building custom MCP server

epsteinexposed-mcp

MCP to explore the EpsteinExposed API through the epsteinexposed pip api wrapper.

Gemini MCP

An AI-powered Model Context Protocol server for Claude Code that provides code intelligence tools including codebase analysis, task management, component generation, and deployment configuration.

MedGemma Vertex

MCP server that routes medical questions and images to MedGemma models hosted on Vertex AI, enabling interaction with text-only and multimodal medical AI systems.

WhatsApp Business API MCP Server

An MCP (Multi-Agent Conversation Protocol) Server that enables interaction with the WhatsApp Business API, allowing agents to send messages, manage media, and perform other WhatsApp business operations through natural language.

MOIDVK

A comprehensive Model Context Protocol (MCP) server that provides 37+ intelligent development tools across JavaScript/TypeScript, Rust, and Python with security-first design and high-performance features.

Basic MCP Application

Aplikasi sederhana yang mendemonstrasikan integrasi Model Context Protocol (MCP) dengan FastAPI dan Streamlit, memungkinkan pengguna untuk berinteraksi dengan LLM melalui antarmuka yang bersih.

aws-mcp-cloud-dev

AI-powered cloud development with AWS MCP Servers

mcp-cloudflare

Slim Cloudflare MCP Server — 42 tools for managing DNS, zones, tunnels, WAF, Zero Trust, and security via Cloudflare API v4. Multi-zone support. No SSH, no shell, API-only with 3 runtime dependencies. AGPL-3.0 + Commercial dual-licensed.

FamilySearch MCP Server

Server Protokol Konteks Model yang memungkinkan alat AI seperti Claude atau Cursor untuk berinteraksi langsung dengan data sejarah keluarga FamilySearch, termasuk mencari catatan orang, melihat informasi detail, dan menjelajahi leluhur dan keturunan.

Red Team MCP

A multi-agent collaboration platform that provides access to over 1,500 models from 68 providers via the Model Context Protocol. It enables users to assemble and coordinate specialized AI teams using advanced orchestration modes like swarm, debate, and hierarchical workflows.

Garak-MCP

Server MCP untuk Pemindai Kerentanan Garak LLM https://github.com/EdenYavin/Garak-MCP/blob/main/README.md

SpiderFoot MCP Server

Enables interaction with SpiderFoot OSINT reconnaissance tools through MCP, allowing users to manage scans, retrieve modules and event types, access scan data, and export results. Supports both starting new scans and analyzing existing reconnaissance data through natural language.

Claude Runner MCP

An MCP server for scheduling and executing Claude Code CLI tasks via cron expressions, featuring a web dashboard and webhook support. It enables users to dynamically create custom MCP servers, manage recurring AI jobs, and track execution history with token and cost analytics.