Discover Awesome MCP Servers

graphql2mcp

Convert GraphQL schemas and endpoints into Model Context Protocol (MCP) servers.

Spotify MCP Server

Connects Claude to Spotify, enabling play control, playlist management, lyrics retrieval, and music recommendations through natural language.

Forge

Terminal MCP server for AI coding agents with persistent PTY sessions, ring-buffer incremental reads, headless xterm screen capture, multi-agent orchestration, and a real-time web dashboard.

REAPER MCP Server

A Model Context Protocol server that enables AI agents to create fully mixed and mastered tracks in REAPER DAW, supporting project management, MIDI composition, audio recording, and mixing automation.

GitBranchMCP

A local-first MCP server for AI programming branch notes and mainline decision logging, supporting branch management, summary merging, and Markdown export with optional Git-mode for isolated branch conversations.

imagedimensions-mcp

Audits images on any public web page to detect oversized images, compare natural vs rendered dimensions, and provide format breakdown, helping AI agents check image performance during development.

chia-explorer

MCP server that answers questions about the Chia blockchain, including balances, blocks, transactions, offers, fees, and more, using the public coinset.org API and CoinGecko for pricing.

Sketchup Integration

Menghubungkan Sketchup ke Claude AI melalui Protokol Konteks Model, memungkinkan Claude untuk berinteraksi secara langsung dengan dan mengendalikan Sketchup untuk pemodelan 3D dan manipulasi adegan yang dibantu oleh perintah (prompt).

Godalo

Affiliate product search for AI agents. Indexes structured merchant feeds — real prices, live stock, affiliate links built in. Works with any MCP client.

FHIR MCP Server

A comprehensive MCP server that bridges AI applications with FHIR healthcare data systems, enabling patient data access, clinical data retrieval, and data quality assessment.

mcp-stm-montevideo

MCP server exposing Montevideo public transportation data (STM) as tools for AI assistants, enabling natural language queries about routes, stops, arrivals, and trip planning.

MCP Sigmund

Enables AI assistants to analyze personal financial data from Open Banking sources stored in PostgreSQL database. Provides educational financial analysis tools with intelligent formatting for learning about spending patterns, account balances, and transaction history.

API Wrapper MCP Server

Okay, I understand you want to create an MCP (Mod Configuration Protocol) server for *any* API. This is a bit broad, as the specific implementation will depend heavily on the API you're targeting and what you want to configure. However, I can give you a general outline and code snippets to get you started. **What is MCP (Mod Configuration Protocol)?** MCP is a protocol used in Minecraft modding to allow mods to communicate configuration information to a central server. This allows for dynamic configuration changes without requiring restarts or manual file editing. While originally designed for Minecraft, the core concepts can be adapted to other APIs. **General Architecture** 1. **API (Target API):** This is the API you want to configure. It could be a game server, a web service, or any other application with configurable parameters. 2. **MCP Server:** This server listens for configuration requests from MCP Clients. It stores the current configuration and applies changes to the Target API. 3. **MCP Client:** This client (usually a mod or a separate application) allows users to view and modify the configuration. It sends requests to the MCP Server. **Steps to Create an MCP Server (General Outline)** 1. **Choose a Programming Language and Framework:** * **Java:** A common choice, especially if the Target API is also in Java. Use frameworks like Spring Boot or Netty. * **Python:** Good for rapid prototyping and scripting. Use frameworks like Flask or FastAPI. * **Node.js:** Suitable for web-based configuration interfaces. Use frameworks like Express.js. * **Go:** Excellent for performance and concurrency. Use frameworks like Gin or Echo. 2. **Define the Configuration Schema:** * Determine the configurable parameters of the Target API. * Create a data structure (e.g., JSON schema, Java class) to represent the configuration. This will be used for serialization and deserialization. 3. **Implement the MCP Server:** * **Networking:** Set up a server socket to listen for incoming connections from MCP Clients. Use TCP for reliable communication. * **Protocol:** Define a simple protocol for communication. This could be a text-based protocol (e.g., JSON over TCP) or a binary protocol (e.g., Protocol Buffers). The protocol should include messages for: * `GET_CONFIG`: Request the current configuration. * `SET_CONFIG`: Update the configuration. * `CONFIG_UPDATE`: Notification of a configuration change (sent to all connected clients). * **Configuration Storage:** Store the configuration in memory, a file, or a database. * **API Integration:** Implement the logic to apply the configuration changes to the Target API. This is the most API-specific part. It might involve calling API methods, modifying configuration files, or sending commands to the API. * **Security:** Implement authentication and authorization to prevent unauthorized access to the configuration. 4. **Implement the MCP Client (Optional):** * Create a client application that can connect to the MCP Server. * Provide a user interface (GUI or command-line) for viewing and modifying the configuration. * Implement the client-side of the communication protocol. **Example (Conceptual - Python with Flask)** This is a simplified example to illustrate the concepts. It assumes the Target API is a simple application with a single configurable parameter: `message`. ```python from flask import Flask, request, jsonify import threading import socket import json app = Flask(__name__) # Global configuration (in-memory) config = {"message": "Hello, World!"} # Target API (simulated) def apply_config(new_config): global config config = new_config print(f"Configuration updated: {config}") # MCP Server (Flask API) @app.route('/config', methods=['GET', 'PUT']) def manage_config(): global config if request.method == 'GET': return jsonify(config) elif request.method == 'PUT': try: new_config = request.get_json() apply_config(new_config) # Apply to the Target API return jsonify({"message": "Configuration updated successfully"}), 200 except Exception as e: return jsonify({"error": str(e)}), 400 # MCP Server (TCP - for demonstration, Flask is the main server) def tcp_server(): host = 'localhost' port = 12345 server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((host, port)) server_socket.listen(1) print(f"TCP Server listening on {host}:{port}") while True: conn, addr = server_socket.accept() print(f"Connected by {addr}") try: data = conn.recv(1024).decode('utf-8') if not data: continue try: request_data = json.loads(data) request_type = request_data.get("type") if request_type == "GET_CONFIG": response = json.dumps({"type": "CONFIG", "config": config}) conn.sendall(response.encode('utf-8')) elif request_type == "SET_CONFIG": new_config = request_data.get("config") apply_config(new_config) response = json.dumps({"type": "CONFIG_UPDATE", "config": config}) conn.sendall(response.encode('utf-8')) else: conn.sendall(json.dumps({"error": "Invalid request type"}).encode('utf-8')) except json.JSONDecodeError: conn.sendall(json.dumps({"error": "Invalid JSON"}).encode('utf-8')) except Exception as e: print(f"Error handling connection: {e}") finally: conn.close() if __name__ == '__main__': # Start the TCP server in a separate thread tcp_thread = threading.Thread(target=tcp_server) tcp_thread.daemon = True # Allow the main thread to exit even if the TCP thread is running tcp_thread.start() # Start the Flask API server app.run(debug=True) ``` **Explanation:** * **Flask API:** Provides a RESTful API for managing the configuration. This is a more modern approach. * **TCP Server:** Simulates a basic MCP-style TCP server. It listens for `GET_CONFIG` and `SET_CONFIG` requests. * **`apply_config()`:** This function is the key. It's where you would integrate with the Target API to apply the configuration changes. In this example, it just updates the `config` variable. * **JSON:** Uses JSON for serialization and deserialization of configuration data. **MCP Client (Conceptual - Python)** ```python import socket import json def get_config(): host = 'localhost' port = 12345 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client_socket.connect((host, port)) request = {"type": "GET_CONFIG"} client_socket.sendall(json.dumps(request).encode('utf-8')) response = client_socket.recv(1024).decode('utf-8') client_socket.close() try: response_data = json.loads(response) if response_data.get("type") == "CONFIG": return response_data.get("config") else: print(f"Error: {response_data.get('error')}") return None except json.JSONDecodeError: print("Invalid JSON response") return None def set_config(new_config): host = 'localhost' port = 12345 client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client_socket.connect((host, port)) request = {"type": "SET_CONFIG", "config": new_config} client_socket.sendall(json.dumps(request).encode('utf-8')) response = client_socket.recv(1024).decode('utf-8') client_socket.close() try: response_data = json.loads(response) if response_data.get("type") == "CONFIG_UPDATE": print("Configuration updated successfully.") else: print(f"Error: {response_data.get('error')}") except json.JSONDecodeError: print("Invalid JSON response") if __name__ == '__main__': current_config = get_config() if current_config: print(f"Current configuration: {current_config}") new_message = input("Enter a new message: ") new_config = {"message": new_message} set_config(new_config) ``` **Key Considerations:** * **API-Specific Integration:** The `apply_config()` function is where you'll need to write code that interacts with the Target API. This will vary greatly depending on the API. * **Error Handling:** Implement robust error handling to catch exceptions and provide informative error messages. * **Security:** Implement authentication and authorization to protect the configuration from unauthorized access. Consider using TLS/SSL for secure communication. * **Scalability:** If you need to handle a large number of clients, consider using a more scalable architecture (e.g., message queues, load balancing). * **Configuration Reloading:** Implement a mechanism to reload the configuration without restarting the Target API. This might involve using a file watcher or a signal handler. * **Real-time Updates:** Use WebSockets or Server-Sent Events (SSE) to push configuration updates to clients in real-time. **How to Adapt to Your Specific API:** 1. **Identify Configurable Parameters:** List all the settings you want to be able to change remotely. 2. **Understand the API:** Read the API documentation to understand how to modify those settings. Does it have an API endpoint? Does it require modifying a configuration file? Does it require sending commands? 3. **Implement `apply_config()`:** Write the code in the `apply_config()` function to use the API to apply the new configuration. This is the most important step. 4. **Test Thoroughly:** Test your MCP server and client to ensure that configuration changes are applied correctly and that the Target API behaves as expected. **Example Scenario: Configuring a Game Server** Let's say you want to configure a game server that has settings like `max_players`, `game_mode`, and `motd`. 1. **Configuration Schema:** ```json { "max_players": 20, "game_mode": "survival", "motd": "Welcome to the server!" } ``` 2. **API Integration:** You would need to find out how to change these settings in the game server. It might involve: * Modifying a `server.properties` file. * Sending RCON commands to the server. * Using a game server API (if one exists). 3. **`apply_config()` Implementation:** The `apply_config()` function would read the new configuration, then use the appropriate method to update the game server's settings. **Important Notes:** * This is a general outline. The specific implementation will depend on the Target API and your requirements. * Start with a simple prototype and gradually add features. * Focus on making the `apply_config()` function work correctly. * Consider using existing libraries and frameworks to simplify the development process. This detailed explanation and example should give you a solid foundation for creating your MCP server. Remember to adapt the code and concepts to your specific API. Good luck!

MISP-mcp

Enables AI assistants to interact with MISP threat intelligence platforms through natural language, supporting event search, creation, user management, and report generation.

Name.com MCP Server

Enables management of domains and DNS records through the Name.com REST API. Users can search for available domains, check bulk availability, and configure DNS records or nameservers using natural language.

MCP Twitter/X Server

Provides integration with Twitter/X, enabling reading posts from users and creating new posts.

YouTrack MCP Server

A comprehensive Model Context Protocol server for YouTrack integration, providing extensive tools for issue tracking, project management, workflow automation, and team collaboration.

goodvat

Enables AI assistants to answer tax compliance questions (VAT, sales tax, GST) and validate EU VAT numbers in real time via the VIES registry.

Jokes MCP Server

A Model Context Protocol server that provides jokes on demand, allowing users to request jokes from different categories (Chuck Norris, Dad jokes, etc.) and integrate them into Microsoft Copilot Studio and Visual Studio Code.

MCP GitHub Dashboard

A comprehensive GitHub project dashboard for MCP that monitors multiple repositories, pull requests, issues, deployments, and health status through AI assistants.

WhisperGraph MCP Server

Self-hostable MCP server for WhisperGraph — a graph of 7.39B nodes / 39B edges mapping DNS, BGP, GeoIP, WHOIS, and threat intelligence. Six read-only tools (Cypher query + schema introspection + threat assessment), six resources, eight investigation prompts. stdio and Streamable HTTP transports.

golf-reports

Pulls golf data from Arccos, GHIN, and 18Birdies, and generates interactive HTML and PDF round reports with shot maps and stats via local MCP tools.

Anam MCP Server

Enables managing AI personas, avatars, voices, and sessions from any MCP client, for integration with Anam AI.

Jira MCP Server

Enables comprehensive interaction with self-hosted Jira instances using Personal Access Token authentication, supporting issue management, JQL searches, comments, transitions, projects, and custom fields through 27 specialized tools.

Agent Lab

Run and test agentic systems in isolated Docker sandboxes, varying system prompts, models, and task prompts while capturing full behavior traces via MCP tools.

xamp

MCP server that gives Claude Code and OpenCode direct access to your XAMPP MariaDB/MySQL databases, enabling database listing, table inspection, and read/write query execution.

Typefully MCP Server

A Model Context Protocol server that enables AI assistants to create and manage Twitter drafts on Typefully, supporting features like thread creation, scheduling, and retrieving published content.

Barebones MCP Server

A minimal, dockerized template for creating HTTP-based Model Context Protocol servers. Provides a starting point with FastMCP framework integration and includes a sample cat fact tool that can be replaced with custom functionality.

browser-smoke

Enables browser automation and smoke testing via Playwright, with tools for navigation, DOM interaction, screenshots, network capture, and more.

Cloudflare Email MCP Server

Manages Cloudflare KV namespaces and automates email processing from ProtonMail Bridge to structured KV storage with folder mapping.