Discover Awesome MCP Servers

mcp-local-image-reader

A simple MCP server that reads local images and returns them as ImageContent for LLM vision analysis.

MCP SQLite Server

Query, explore, and manage SQLite databases through the Model Context Protocol. Connect any MCP-compatible AI client to your databases.

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.

openkrx-mcp

MCP server that provides Korean Exchange (KRX) Open API market data as tools, covering indices, stocks, ETPs, bonds, derivatives, commodities, and ESG.

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.

Oracle Cloud Infrastructure (OCI) MCP Server

A Model Context Protocol server for managing Oracle Cloud Infrastructure services, enabling LLMs to interact with compute instances, storage, identity, and databases through natural language.

The Hive Doctrine — MCP Server

An agent knowledge marketplace for polytheistic AI safety, offering 105 products across tiers, with tools to browse, search, and access free and paid content.

mcp-server-salesforce

Provides AI agents with secure access to Salesforce data and operations, enabling natural language interaction with CRM for sales, marketing, and executive teams.

Banking MCP Server

A comprehensive banking system with MCP server capabilities and REST API, enabling account management, deposits, withdrawals, transfers, and transaction history through natural language or HTTP endpoints.

Bilka MCP Server

A template MCP server for integrating with public APIs, providing a starting point for building custom API integrations.

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.

dice-mcp

Enables rolling dice with customizable sides and counts, returning results and totals via MCP Streamable HTTP transport.

mcp_server

Okay, I understand. You want guidance on implementing a sample MCP (Management Control Protocol) server that can interact with a Dolphin MCP client. Here's a breakdown of the steps involved, along with code snippets and explanations to get you started. Keep in mind this is a simplified example and you'll need to adapt it to your specific needs and the full Dolphin MCP specification. **1. Understanding the Basics** * **MCP (Management Control Protocol):** A protocol used for managing and controlling devices or applications. It typically involves a client (the Dolphin MCP client in your case) sending commands to a server, and the server responding with status updates or data. * **Dolphin MCP Client:** This is the client application that will be sending requests to your server. You'll need to understand the specific commands and data formats that the Dolphin MCP client uses. **Crucially, you need the Dolphin MCP client's documentation or API specification.** Without that, you're essentially guessing. * **Server Implementation:** You'll need to choose a programming language and framework to build your server. Common choices include Python, Java, Go, or C++. I'll provide examples in Python because it's relatively easy to read and prototype with. * **Communication:** MCP often uses TCP/IP sockets for communication. Your server will need to listen on a specific port for incoming connections from the Dolphin MCP client. **2. Key Steps** 1. **Define the MCP Protocol (Based on Dolphin MCP Client Documentation):** * **Commands:** List the commands the Dolphin MCP client will send (e.g., `GET_STATUS`, `SET_VALUE`, `REBOOT`). * **Data Formats:** Determine the format of the data exchanged (e.g., plain text, JSON, XML, binary). This is *critical*. If the Dolphin client expects JSON, you *must* send JSON. * **Error Handling:** Define how the server will report errors to the client. 2. **Set up a TCP Socket Server:** * Create a socket that listens on a specific port. * Accept incoming connections from clients. 3. **Receive and Parse Client Requests:** * Read data from the socket. * Parse the data to identify the MCP command and any associated parameters. 4. **Process the Command:** * Implement the logic to handle each MCP command. This might involve reading data from a database, controlling hardware, or performing other actions. 5. **Send a Response:** * Format a response according to the MCP protocol. * Send the response back to the client over the socket. 6. **Error Handling:** * Implement error handling to catch exceptions and send appropriate error responses to the client. **3. Python Example (Simplified)** ```python import socket import threading import json # For JSON data format (if used) # Configuration HOST = '127.0.0.1' # Listen on localhost PORT = 12345 # Choose a port # Sample MCP Commands (Adapt to Dolphin MCP Client's commands!) CMD_GET_STATUS = "GET_STATUS" CMD_SET_VALUE = "SET_VALUE" CMD_REBOOT = "REBOOT" # Sample Data (Replace with your actual data) device_status = "OK" device_value = 50 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 message = data.decode('utf-8').strip() # Decode the message print(f"Received: {message}") # **Crucially, parse the message based on the Dolphin MCP client's format.** # This is a very basic example. You'll likely need a more robust parser. parts = message.split() command = parts[0] if command == CMD_GET_STATUS: response = f"STATUS: {device_status}\n" # Simple text response conn.sendall(response.encode('utf-8')) elif command == CMD_SET_VALUE: try: new_value = int(parts[1]) device_value = new_value response = f"VALUE_SET: {device_value}\n" conn.sendall(response.encode('utf-8')) except (IndexError, ValueError): response = "ERROR: Invalid SET_VALUE command\n" conn.sendall(response.encode('utf-8')) elif command == CMD_REBOOT: print("Simulating reboot...") response = "REBOOTING\n" conn.sendall(response.encode('utf-8')) # Add actual reboot logic here (carefully!) else: response = "ERROR: Unknown command\n" conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") def main(): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 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 of the Python Code:** * **`import socket, threading, json`:** Imports necessary modules. `socket` for network communication, `threading` for handling multiple clients concurrently, and `json` for handling JSON data (if needed). * **`HOST`, `PORT`:** Defines the IP address and port the server will listen on. * **`CMD_GET_STATUS`, `CMD_SET_VALUE`, `CMD_REBOOT`:** Defines the MCP commands. **Replace these with the actual commands used by the Dolphin MCP client.** * **`device_status`, `device_value`:** Sample data that the server will manage. * **`handle_client(conn, addr)`:** This function handles communication with a single client. * `conn.recv(1024)`: Receives data from the client. * `data.decode('utf-8').strip()`: Decodes the data (assuming UTF-8 encoding) and removes leading/trailing whitespace. * `message.split()`: Splits the message into parts (command and parameters). **This is a very basic parsing method. You'll likely need a more sophisticated parser based on the Dolphin MCP client's data format.** * The `if/elif/else` block handles the different MCP commands. **Implement the actual logic for each command here.** * `conn.sendall(response.encode('utf-8'))`: Sends the response back to the client. * Error handling is included in the `try...except...finally` block. * **`main()`:** * Creates a TCP socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * When a client connects, it creates a new thread to handle the client. **Important Considerations and Next Steps:** 1. **Dolphin MCP Client Documentation is Essential:** You *must* have the documentation for the Dolphin MCP client to understand the protocol it uses. This is the most important step. Contact the vendor or developer of the Dolphin MCP client to obtain this documentation. 2. **Data Format:** Determine the data format used by the Dolphin MCP client (e.g., JSON, XML, plain text, binary). Adjust the parsing and response formatting in the code accordingly. If it's JSON, use the `json` module to encode and decode data. 3. **Error Handling:** Implement robust error handling to catch exceptions and send appropriate error responses to the client. 4. **Security:** If the MCP protocol is used over a network, consider security implications. You might need to implement authentication and encryption. 5. **Scalability:** If you need to handle a large number of clients, consider using a more scalable architecture, such as asynchronous I/O (e.g., using `asyncio` in Python). 6. **Testing:** Thoroughly test your server with the Dolphin MCP client to ensure that it works correctly. **Example with JSON (if the Dolphin MCP client uses JSON):** ```python import socket import threading import json # ... (HOST, PORT, etc. as before) def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8').strip() print(f"Received: {message}") try: request = json.loads(message) # Parse JSON command = request.get("command") params = request.get("params", {}) # Get parameters (optional) if command == "GET_STATUS": response_data = {"status": device_status} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) elif command == "SET_VALUE": try: new_value = int(params.get("value")) device_value = new_value response_data = {"result": "VALUE_SET", "value": device_value} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) except (KeyError, ValueError): response_data = {"error": "Invalid SET_VALUE command"} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) # ... (other commands) else: response_data = {"error": "Unknown command"} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) except json.JSONDecodeError: response_data = {"error": "Invalid JSON format"} response = json.dumps(response_data) + "\n" conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: conn.close() print(f"Connection closed with {addr}") # ... (main() function as before) ``` **Key changes in the JSON example:** * `json.loads(message)`: Parses the incoming message as JSON. * `request.get("command")`: Extracts the command from the JSON object. * `params = request.get("params", {})`: Extracts the parameters (if any) from the JSON object. The `{}` provides a default empty dictionary if the "params" key is missing. * `json.dumps(response_data)`: Converts the response data to a JSON string. * `json.JSONDecodeError`: Handles errors if the incoming message is not valid JSON. **In summary, the most important thing is to get the Dolphin MCP client's documentation and understand the protocol it uses. Then, adapt the code examples above to match the specific requirements of the protocol.**

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.

typescript-mcp-server

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

Neuratel MCP Server

Control your voice AI platform through natural language from any MCP-compatible assistant.

Basic MCP Server

A minimal Model Context Protocol (MCP) server demonstrating the implementation of tools, resources, and prompts. It serves as a starter template built with the Smithery SDK for developing custom integrations.

MarkdownPointer

Enables AI to open, navigate, and export Markdown documents, and to import/export PPTX files.

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.

godot-mcp-bridge

Let Claude, Cursor, or any MCP-compatible AI work inside your Godot project: read and edit scenes, write and validate scripts, run the game, drive it, and read the errors — without copy-pasting anything.

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.

Windows CLI MCP Server

A Model Context Protocol server that provides secure command-line access to Windows systems, allowing MCP clients like Claude Desktop to safely execute commands in PowerShell, CMD, and Git Bash shells with configurable security controls.

Multi MCP

A flexible proxy server that aggregates multiple backend MCP servers into a single interface using STDIO or SSE transports. It supports dynamic server management via an HTTP API and utilizes namespacing to prevent tool conflicts across connected services.

Octopus Energy MCP Server

Enables retrieval of electricity and gas consumption data from Octopus Energy accounts through their API, with support for date range filtering, pagination, and grouping by time periods.

minecraft-admin-mcp

A lightweight, self-hosted MCP server that provides a small set of administration tools for a single Minecraft Java Edition server, including whitelist management, broadcasting, kicking, backups, and monitoring, with secure RCON-based operations and audit logging.

WAHA MCP Server

Bridges the WhatsApp HTTP API with AI assistants to enable full control over messaging, chat management, and interactive workflows through 63 specialized tools. It allows users to automate WhatsApp tasks and receive real-time AI feedback directly on their mobile devices.