Discover Awesome MCP Servers

dns-whois-mcp

FastMCP server for DNS lookups and WHOIS domain research, enabling comprehensive domain investigation with parallel DNS records, WHOIS, and reverse lookups.

linkedin-web-scrapper-mcp-server

Provides tools for searching LinkedIn profiles and extracting names, URLs, and headlines via Playwright-based web scraping. Supports location and network filters with automatic login and cookie persistence.

FaxSeal MCP Server

Send, receive, and verify faxes from AI assistants and agents via the Model Context Protocol.

OpenProject MCP Server

Enables LLM applications to interact with OpenProject for project management, work package tracking, and task creation.

FastMCP LaTeX Server (tex-mcp)

MCP server that renders LaTeX to PDF via pdflatex, supporting raw LaTeX and Jinja2 templates with artifact generation.

agentmemory-codex-windows

Enables persistent, project-scoped memory for OpenAI Codex Desktop and CLI on Windows, capturing prompts and responses through managed hooks, with federated recall across projects and optional local graph extraction.

Reddit User MCP Server

Enables interaction with Reddit through a Reddable account, allowing users to fetch posts and comments, reply to discussions, and manage comment visibility using secure API key authentication.

Planning Center Online API and MCP Server Integration

Servidor MCP de Planning Center Online

codex-commit-review-mcp

Enables auditable, plan-linked Git commit review views for Codex, with interactive file trees, split diffs, line-level explanations, and SHA-256 audit receipts served locally on localhost.

weather-mcp

A FastMCP server that provides current weather, forecasts, and rule-based umbrella/jacket recommendations via Open-Meteo, deployable to Databricks Agent Bricks.

Aquifer MCP

Thin Cloudflare Workers MCP server for navigating Bible Aquifer content, enabling Bible verse retrieval, content search, and entity profiling through MCP tools.

b4n1-web

Ultra-lightweight headless browser for AI agents. Provides MCP tools for navigating URLs, extracting structured content, and building autonomous agent workflows.

Agent Escalation Harness

An MCP server that lets an AI coding agent pause on human-only tasks, request structured input via a form, and resume with the answer, all locally without cloud dependencies.

domainkits-mcp

DomainKits MCP connects AI assistants (Claude, GPT, etc.) to professional domain intelligence tools. Instead of guessing domain availability, the AI can actually check it. Instead of generic naming suggestions, it validates ideas against real market data.

Firefly III MCP Server

Enables interaction with Firefly III personal finance tools through natural language, deployed globally on Cloudflare Workers for low latency and high availability.

bidirectional-bridge-claude-codex

A local, repository-scoped MCP coordination bridge that lets Claude Code and Codex work together in the same checkout via tasks, leases, and evidence-based completion, preventing conflicting edits and enabling bounded delegation.

Payments Agent Gateway (MCP)

An MCP server that enables AI agents to safely interact with a double-entry payments ledger, enforcing idempotency, policy-based access control, and human-in-the-loop approval for high-value actions.

AgentOps

MCP server that browses the web, checks conditions (price, text, stock), and takes autonomous actions like form filling, with n8n notifications and a dashboard.

Proxmox MCP Enhanced

Provides a complete MCP server for managing Proxmox VE infrastructure with 115 specialized tools, enabling AI assistants and automation systems to perform complex virtualization tasks seamlessly.

mcp-gopls

A Model Context Protocol (MCP) server that allows AI assistants like Claude to interact with Go's Language Server Protocol (LSP) and benefit from advanced Go code analysis features.

note-mcp

Unofficial MCP server for note.com using cookie-based authentication to manage notes and drafts via internal APIs.

UniFi Network MCP Server

Enables AI assistants to manage UniFi network infrastructure through 50+ tools covering devices, clients, networks, WiFi, firewall rules, and guest access using the official UniFi Network API.

x402-agent-data

Pay-per-call MCP server offering crypto market signals, web page extraction, and GitHub repo auditing, with automatic settlement in USDC via the x402 protocol.

Sp MCP Server

Enables publishing images with captions to connected Instagram accounts and listing those accounts, allowing Claude to manage Instagram posts for Sp platform users.

velesdb-memory

Local-first agent-memory MCP server with a why() tool: recall a fact together with its connected subgraph (multi-hop), so linked memories surface even when they share no words with the query. remember/recall/relate/forget/why over one fused vector + graph + columnar engine a single offline Rust binary.

typescript-mcp-server

A TypeScript boilerplate for building Model Context Protocol (MCP) servers with example tools (calculator, greet) and resources (system info).

mcp_server

Okay, I can help you outline the steps and provide some code snippets to guide you in implementing a sample MCP (Media Control Protocol) server using a Dolphin MCP client. Keep in mind that this is a simplified example, and a full implementation would require more robust error handling, state management, and feature support. **Conceptual Overview** 1. **Dolphin MCP Client:** This is the application (e.g., a media player, a control panel) that sends MCP commands to the server. We'll assume you have a Dolphin MCP client already available or are using a library that emulates one. 2. **MCP Server:** This is the application you'll build. It listens for incoming MCP connections, parses the commands, performs actions based on those commands, and sends responses back to the client. **Steps to Implement a Sample MCP Server** 1. **Choose a Programming Language and Libraries:** * **Python:** A good choice for rapid prototyping and ease of use. Use the `socket` library for network communication. * **Node.js:** Suitable for asynchronous, event-driven servers. Use the `net` module. * **Java:** A robust option for larger, more complex servers. Use the `java.net` package. * **C#:** Well-suited for Windows environments. Use the `System.Net.Sockets` namespace. For this example, I'll use Python because it's concise and widely accessible. 2. **Set up a Socket Server:** * Create a socket that listens on a specific port (e.g., 9000). * Accept incoming connections from clients. 3. **Receive and Parse MCP Commands:** * Read data from the socket. * Parse the incoming data as MCP commands. You'll need to understand the MCP command format (e.g., command codes, parameters). Refer to the Dolphin MCP documentation for details. * Common MCP commands include: * `PLAY` * `PAUSE` * `STOP` * `SEEK` * `VOLUME` * `STATUS` 4. **Implement Command Handlers:** * Create functions or methods to handle each MCP command. * These handlers will perform the appropriate actions (e.g., start playback, pause playback, set the volume). * For this sample, we'll simulate these actions (e.g., print a message to the console). 5. **Send Responses:** * After processing a command, send a response back to the client. * Responses typically include a status code (e.g., `OK`, `ERROR`) and any relevant data. **Python Example Code** ```python import socket HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 9000 # Port to listen on (non-privileged ports are > 1023) def handle_play(): print("Received PLAY command. Simulating playback...") return "OK: Playing" def handle_pause(): print("Received PAUSE command. Simulating pause...") return "OK: Paused" def handle_stop(): print("Received STOP command. Simulating stop...") return "OK: Stopped" def handle_seek(time): print(f"Received SEEK command. Seeking to {time}...") return f"OK: Seeked to {time}" def handle_volume(level): print(f"Received VOLUME command. Setting volume to {level}...") return f"OK: Volume set to {level}" def handle_status(): print("Received STATUS command. Returning status...") return "OK: Status - Playing" # Replace with actual status def process_command(command): """Parses and executes MCP commands.""" parts = command.split(" ") command_name = parts[0].upper() if command_name == "PLAY": return handle_play() elif command_name == "PAUSE": return handle_pause() elif command_name == "STOP": return handle_stop() elif command_name == "SEEK": if len(parts) > 1: try: time = int(parts[1]) return handle_seek(time) except ValueError: return "ERROR: Invalid time format" else: return "ERROR: Missing time parameter" elif command_name == "VOLUME": if len(parts) > 1: try: level = int(parts[1]) return handle_volume(level) except ValueError: return "ERROR: Invalid volume level" else: return "ERROR: Missing volume level parameter" elif command_name == "STATUS": return handle_status() else: return "ERROR: Unknown command" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break # Client disconnected command = data.decode().strip() # Decode bytes to string and remove leading/trailing whitespace print(f"Received command: {command}") response = process_command(command) conn.sendall(response.encode()) # Encode the response back to bytes print("Server stopped.") ``` **Explanation:** * **`socket.socket()`:** Creates a socket object. * **`s.bind()`:** Binds the socket to a specific address and port. * **`s.listen()`:** Enables the server to accept connections. * **`s.accept()`:** Accepts a connection from a client. Returns a new socket object (`conn`) representing the connection and the client's address (`addr`). * **`conn.recv()`:** Receives data from the client. * **`data.decode()`:** Decodes the received bytes into a string. * **`process_command()`:** Parses the command and calls the appropriate handler function. * **`conn.sendall()`:** Sends data back to the client. * **`data.encode()`:** Encodes the response string back into bytes. **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` **Testing with a Simple Client (netcat)** You can use `netcat` (often abbreviated as `nc`) to simulate a Dolphin MCP client for testing: 1. Open a new terminal window. 2. Connect to the server: `nc localhost 9000` 3. Type MCP commands (e.g., `PLAY`, `PAUSE`, `VOLUME 50`, `STATUS`) and press Enter. 4. You should see the server's responses in the `netcat` terminal and the server's output in the server's terminal. **Important Considerations:** * **Error Handling:** The example code has minimal error handling. You should add more robust error handling to catch exceptions and handle invalid input. * **MCP Specification:** Refer to the official Dolphin MCP documentation for the exact command formats, status codes, and data structures. The example code assumes a simplified command format. * **Threading/Asynchronous Operations:** For a production server, use threading or asynchronous operations (e.g., `asyncio` in Python, `Promises` in Node.js) to handle multiple client connections concurrently. The single-threaded example above will only handle one client at a time. * **Security:** If you're exposing the server to a network, consider security implications (e.g., authentication, authorization). * **State Management:** The server needs to maintain state (e.g., the current playback status, volume level) to respond correctly to commands. * **Real Media Control:** The example only *simulates* media control. To actually control media playback, you'll need to integrate with a media player library or API (e.g., VLC, GStreamer). **Next Steps:** 1. **Study the Dolphin MCP Specification:** This is crucial for understanding the exact command formats and protocols. 2. **Implement More Commands:** Add handlers for all the MCP commands you want to support. 3. **Add Error Handling:** Make the server more robust by handling potential errors. 4. **Implement Concurrency:** Use threading or asynchronous operations to handle multiple clients. 5. **Integrate with a Media Player:** Connect the server to a media player library to control actual media playback. This detailed explanation and code example should give you a solid foundation for building your MCP server. Remember to consult the Dolphin MCP documentation for the most accurate and up-to-date information. Good luck!

MCP Python Interpreter with Docker

Enables executing Python code, managing environments and packages, and performing file operations within Docker containers.

AMFI MCP Server

Provides AI assistants with real-time Indian mutual fund NAV data from AMFI's official feed, requiring no API key.

agent-vision-mcp

Enables non-vision LLMs to analyze images via any OpenAI-compatible vision API. Hardened against truncation, empty responses, and timeouts for reliable analysis.