Discover Awesome MCP Servers

MLB V3 Scores MCP Server

An MCP Server that enables interaction with MLB scores and statistics via the SportsData.io MLB V3 Scores API, allowing users to access baseball data through natural language queries.

Remote MCP Server

A Cloudflare Workers-based implementation of Model Context Protocol (MCP) server that enables AI tools like Claude to connect to external services through OAuth login.

HubSpot MCP Server

Enables AI assistants to interact with HubSpot CRM for managing contacts, companies, deals, and sending emails through natural language commands.

PostgreSQL MCP Server

Enables direct execution of PostgreSQL queries through the Model Context Protocol. Supports both SELECT and non-SELECT operations with dual communication modes (stdio and HTTP REST API).

Kaspersky OpenTIP MCP Server

Kaspersky OpenTIP Model Context Protocol Server. This server gives access to Kaspersky OpenTIP API to agentic applications.

MusicMCP.AI

Enables AI-powered music generation through natural language commands, supporting both inspiration mode (AI-generated lyrics and style) and custom mode (user-provided lyrics and parameters) to create songs with direct download links.

Shopify MCP Server

Enables interaction with Shopify store data through GraphQL API, providing tools for managing products, customers, orders, blogs, and articles.

Skillz

Turns Claude-style skills (SKILL.md files with resources) into callable MCP tools for any agent. Discovers skills from a directory, exposes their instructions and resources, and can execute bundled helper scripts.

Strapi MCP Server

Cermin dari

MCP Toolkit

A modular toolkit for building extensible tool services that fully supports the MCP 2024-11-05 specification, offering file operations, terminal execution, and network requests.

Faraidh MCP Server

Enables Islamic inheritance law calculations (Faraidh) including heir validation, estate distribution, and handling special cases like Aul and Radd. Supports comprehensive inheritance scenarios with detailed reporting and case management functionality.

MCP SCP Server

Enables secure file transfer operations with remote Linux and Windows systems via SCP/SFTP protocols. Supports uploading, downloading, listing, and managing files on remote servers through SSH authentication.

tavily-mcp-python

Tavily MCP Server implementation that uses fastmcp and supports both sse and stdio transports. It also supports more up to date functionalities of Tavily.

OpenStack MCP Server

Layanan ringan dan mudah diperluas yang memungkinkan asisten AI untuk menjalankan perintah OpenStack CLI secara aman melalui Model Context Protocol (MCP).

My MCP Server

A comprehensive MCP server providing arithmetic tools, dynamic file resources for frontend/backend documentation, reusable prompt templates for code review/debugging/testing, and complete development workflow management from requirements to deployment.

smartthings-mcp

A lightweight server for Samsung SmartThings, offering tools to manage devices and rooms. Features include room mapping, device listing, status checks, and command execution. #IoT, #Python, #HomeAutomation #Smartthings

MCP Servers and Tools I Use

Berikut adalah dokumentasi server dan alat MCP yang saya gunakan dengan Claude:

MCP-Server-MySSL

MySSL MCP Server

mcp_server

Okay, here's a basic outline and example code snippets to guide you in implementing a sample MCP (Media Control Protocol) server using a Dolphin MCP client. This will be a simplified example to illustrate the core concepts. **Understanding the Components** * **MCP (Media Control Protocol):** A protocol for controlling media playback devices. It defines commands like play, pause, stop, seek, and volume control. * **Dolphin MCP Client:** A library or tool (presumably you have access to this) that acts as the client in the MCP communication. It sends commands to the MCP server. * **MCP Server:** The application you'll build. It listens for MCP commands from the Dolphin MCP client, interprets them, and then performs the corresponding actions (e.g., controlling a media player). **High-Level Steps** 1. **Choose a Programming Language and Framework:** Python is a good choice for its simplicity and networking libraries. You could use the `socket` module directly or a framework like `asyncio` for asynchronous handling. 2. **Set up a Socket Server:** Create a socket server that listens on a specific port (e.g., 5000). This server will accept connections from the Dolphin MCP client. 3. **Receive and Parse MCP Commands:** When a client connects, receive data from the socket. This data will be the MCP command. You'll need to parse the command string to determine the action to perform. 4. **Implement Command Handlers:** Create functions or methods to handle each MCP command (e.g., `handle_play()`, `handle_pause()`, `handle_seek()`). These handlers will interact with your media player (or a simulated media player for testing). 5. **Send Responses (Optional):** The MCP protocol may define response messages. You can send acknowledgements or status updates back to the client. 6. **Error Handling:** Implement error handling to gracefully deal with invalid commands, network issues, and other potential problems. **Python Example (using `socket` module)** ```python import socket import threading HOST = '127.0.0.1' # Loopback address (localhost) PORT = 5000 # Port to listen on # Simulated Media Player (replace with actual media player control) class MediaPlayer: def __init__(self): self.playing = False self.position = 0 # in seconds self.volume = 100 def play(self): print("Playing...") self.playing = True def pause(self): print("Pausing...") self.playing = False def stop(self): print("Stopping...") self.playing = False self.position = 0 def seek(self, position): print(f"Seeking to {position} seconds...") self.position = position def set_volume(self, volume): print(f"Setting volume to {volume}%") self.volume = volume media_player = MediaPlayer() # Create an instance of the media player def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break command = data.decode('utf-8').strip() # Decode and remove whitespace print(f"Received command: {command}") # Parse the command (very basic example) parts = command.split() action = parts[0].lower() if action == "play": media_player.play() conn.sendall(b"OK\n") # Send a simple acknowledgement elif action == "pause": media_player.pause() conn.sendall(b"OK\n") elif action == "stop": media_player.stop() conn.sendall(b"OK\n") elif action == "seek": try: position = int(parts[1]) media_player.seek(position) conn.sendall(b"OK\n") except (IndexError, ValueError): conn.sendall(b"ERROR: Invalid seek command\n") elif action == "volume": try: volume = int(parts[1]) media_player.set_volume(volume) conn.sendall(b"OK\n") except (IndexError, ValueError): conn.sendall(b"ERROR: Invalid volume command\n") else: print(f"Unknown command: {command}") conn.sendall(b"ERROR: Unknown command\n") except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") def main(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports the necessary modules (`socket` for networking, `threading` for handling multiple clients concurrently). 2. **Constants:** Defines the host and port for the server. 3. **`MediaPlayer` Class:** A simple class to simulate a media player. Replace the placeholder methods with actual media player control code (e.g., using a library like `vlc` or `pygame`). 4. **`handle_client(conn, addr)` Function:** * This function is executed in a separate thread for each client connection. * It receives data from the client using `conn.recv(1024)`. * It decodes the data (assuming UTF-8 encoding) and removes leading/trailing whitespace. * It parses the command string (very basic splitting on spaces). **Important:** A real MCP implementation would likely have a more robust parsing mechanism. * It calls the appropriate `media_player` methods based on the command. * It sends a simple "OK" or "ERROR" response back to the client. * It includes error handling to catch exceptions. * It closes the connection when the client disconnects or an error occurs. 5. **`main()` Function:** * Creates a socket object using `socket.socket(socket.AF_INET, socket.SOCK_STREAM)`. * Binds the socket to the specified host and port using `s.bind((HOST, PORT))`. * Starts listening for incoming connections using `s.listen()`. * Enters a loop that accepts incoming connections using `s.accept()`. * For each connection, it creates a new thread to handle the client using `threading.Thread(target=handle_client, args=(conn, addr))`. * Starts the thread using `thread.start()`. 6. **`if __name__ == "__main__":`:** Ensures that the `main()` function is only executed when the script is run directly (not when it's imported as a module). **How to Run:** 1. Save the code as a Python file (e.g., `mcp_server.py`). 2. Run the script from your terminal: `python mcp_server.py` 3. Use the Dolphin MCP client to connect to `127.0.0.1` on port `5000`. 4. Send MCP commands like "play", "pause", "stop", "seek 10", "volume 50". Observe the output in the server's terminal. **Important Considerations and Improvements:** * **MCP Protocol Specification:** You *must* have the full specification for the MCP protocol you're using. This example is a very simplified approximation. The specification will define the exact command formats, data types, and response codes. * **Robust Command Parsing:** Use a more robust parsing method (e.g., regular expressions, a dedicated parsing library) to handle complex command formats and arguments. * **Error Handling:** Implement comprehensive error handling to catch invalid commands, network errors, and other potential issues. Provide informative error messages to the client. * **Asynchronous I/O:** For a more scalable server, consider using `asyncio` for asynchronous I/O. This allows the server to handle multiple clients concurrently without using threads. * **Media Player Integration:** Replace the `MediaPlayer` class with actual code to control your media player. You might need to use a library specific to your media player (e.g., `vlc`, `pygame`, or a media player's API). * **Security:** If the MCP server will be exposed to a network, consider security implications and implement appropriate security measures (e.g., authentication, authorization, encryption). * **Threading vs. Asynchronous:** For a small number of clients, threading might be sufficient. For a larger number of clients, asynchronous I/O is generally more efficient. * **Dolphin MCP Client Documentation:** Refer to the Dolphin MCP client's documentation for details on how to connect to the server and send commands. **Example Commands from Dolphin MCP Client:** Assuming the Dolphin MCP client sends commands as simple text strings: * `PLAY` * `PAUSE` * `STOP` * `SEEK 60` (Seek to 60 seconds) * `VOLUME 75` (Set volume to 75%) **Indonesian Translation of Key Concepts:** * **MCP (Media Control Protocol):** Protokol Kontrol Media * **Dolphin MCP Client:** Klien Dolphin MCP * **MCP Server:** Server MCP * **Socket:** Soket * **Command:** Perintah * **Parse:** Mengurai (or Memproses) * **Handler:** Penangan * **Response:** Respon * **Error Handling:** Penanganan Kesalahan * **Media Player:** Pemutar Media * **Thread:** Utas (or Alur) * **Asynchronous I/O:** I/O Asinkron This detailed explanation and code example should give you a solid starting point for implementing your MCP server. Remember to adapt the code to your specific needs and the requirements of the Dolphin MCP client and the MCP protocol you're using. Good luck!

Local Documents MCP Server

A Model Context Protocol server that allows AI assistants to discover, load, and process local documents on Windows systems, with support for multiple file formats and OCR capabilities for scanned PDFs.

Usher MCP

Enables users to search and view detailed movie information from TMDB, including cast, ratings, and showtimes, through an interactive widget interface.

Jokes MCP Server

An MCP server that allows Microsoft Copilot Studio to fetch random jokes from three sources: Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

HiveFlow MCP Server

Connects AI assistants (Claude, Cursor, etc.) directly to the HiveFlow automation platform, allowing them to create, manage, and execute automation flows through natural language commands.

Guardian News MCP Server

Enables users to search for the latest news articles from The Guardian using keywords and check service status. Provides access to Guardian's news content through their API with configurable result limits.

Hello MCP

Implementasi server MCP Python minimal dengan MCP Python SDK.

Slack MCP Server

A FastMCP-based server that provides complete Slack integration for Cursor IDE, allowing users to interact with Slack API features using natural language.

Playwright MCP

A Model Context Protocol server that provides browser automation capabilities using Playwright, enabling LLMs to interact with web pages through structured accessibility snapshots without requiring screenshots or visually-tuned models.

Personal JIRA MCP

An MCP server that enables AI assistants to interact with JIRA, allowing for querying issue details, creating and updating work items, and managing attachments through a standardized interface.