Discover Awesome MCP Servers

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.

Baby-SkyNet

Provides Claude AI with persistent, searchable memory management across sessions using SQL database, semantic analysis with multi-provider LLM support (Anthropic/Ollama), vector search via ChromaDB, and graph-based knowledge relationships through Neo4j integration.

MolTrust

MolTrust MCP Server provides AI agents with identity verification, reputation scoring, and verifiable credentials through W3C DID-based trust infrastructure. Includes ERC-8004 on-chain agent registration and Base blockchain anchoring for tamper-proof credential verification.

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.

Usher MCP

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

lu-mcp-server

Verify AI agent communication with session types and formal proofs. 4 tools: parse protocols, verify messages, check safety properties, browse 20 stdlib templates.

Salesforce DX MCP Server

Enables secure interaction with Salesforce orgs through LLMs, providing tools for managing orgs, querying data, deploying metadata, running tests, and performing code analysis. Features granular access control and uses encrypted auth files to avoid exposing secrets in plain text.

Fabric-Analytics-MCP

The Fabric-Analytics-MCP server enables AI agents to interact directly with Microsoft Fabric using natural language. It transforms complex data engineering tasks—such as workspace management, data exploration, and job execution—into intuitive, conversational workflows for LLMs like Claude or GitHub

USolver

A best-effort universal logic and numerical solver interface using MCP that implements the 'LLM sandwich' model to process queries, call dedicated solvers (ortools, cvxpy, z3), and verbalize results.

twitter-voice-mcp

An MCP server that analyzes your unique Twitter voice to generate, manage, and post AI-powered tweets and quote tweet drafts. It supports multiple AI providers and provides tools for draft management, voice profiling, and automated content creation from images.

ikaliMCP Server

Provides a secure interface for AI assistants to interact with penetration testing tools like nmap, hydra, sqlmap, and nikto for educational cybersecurity purposes. Includes input sanitization and runs in a Docker container with Kali Linux tools for authorized testing scenarios.

Kali MCP Server

Provides access to 20+ Kali Linux penetration testing tools through isolated Docker containers, enabling network scanning, vulnerability assessment, password cracking, web security testing, and forensics through natural language commands.

Claude Code AI Collaboration MCP Server

An MCP server that enables multi-provider AI collaboration using models like DeepSeek, OpenAI, and Anthropic through strategies such as parallel execution and consensus building. It provides specialized tools for side-by-side content comparison, quality review, and iterative refinement across different AI providers.

NHN Server MCP

Enables secure SSH access to servers through a gateway with Kerberos authentication, allowing execution of whitelisted commands with pattern-based security controls and server information retrieval.

amap-weather-server

Server cuaca amap dengan MCP

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!

Wise MCP Server

Enables access to Wise API functionality for managing recipients and sending money transfers. Supports listing recipients, creating new recipients, validating account details, and executing money transfers with authentication handling.

Plex MCP Account Finder

Connects to multiple Plex accounts to perform fuzzy searches for users across servers by email, username, or display name, and generates authentication tokens for new account access.

macOS Ecosystem MCP Server

Provides secure access to macOS Reminders, Calendar, and Notes using semantic tools and validated AppleScript templates. It enables users to manage schedules, tasks, and notes through natural language while ensuring multi-layer security validation.

axie-mcp

Provides comprehensive access to Axie Infinity data, including detailed Axie stats, marketplace listings, land information, and player leaderboards. It allows users to query real-time game info and market statistics through natural language.

x.ai Grok MCP Server

Enables chat completions using x.ai's Grok API with support for multiple Grok models (grok-beta, grok-2-latest, grok-4-latest) and configurable parameters like temperature and max tokens.

App Store Connect MCP Server

Enables interaction with Apple's App Store Connect API through natural language to manage apps, beta testing, localizations, analytics, sales reports, and CI/CD workflows for iOS and macOS development.

Migadu MCP Server

Enables AI assistants to manage Migadu email hosting services through natural language, including creating mailboxes, setting up aliases, configuring autoresponders, and handling bulk operations efficiently.

MCP Redirect Server

A Model Context Protocol server built with NestJS that provides OAuth 2.1 authentication with GitHub and exposes MCP tools through Server-Sent Events transport. Enables secure, real-time communication with JWT-based protection and dependency injection.

Google Calendar MCP Server

Enables natural language queries to Google Calendar API for checking appointments, availability, and events. Supports flexible time ranges, timezone handling, and both service account and OAuth authentication methods.

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.

Android Tester MCP

An MCP server for automating virtual or physical Android devices using the Gbox SDK. It enables users to manage app installations, capture screenshots, and perform complex UI actions through natural language instructions.

Weather MCP

A Model Context Protocol server that enables natural language weather queries for global cities, integrating with OpenWeather API to provide real-time weather information in an easy-to-read format.

Element MCP Server

Connects Claude with Matrix/Element to read and search messages across rooms. Enables listing rooms, viewing room information, retrieving message history, and searching conversation content from your Matrix account.