Discover Awesome MCP Servers

MCPify

Automatically generates and runs MCP servers by scraping API documentation and using Gemini to extract endpoints and configuration. It enables users to interact with any REST API through MCP-compatible clients by simply providing a documentation URL.

commercetools MCP Essentials

An MCP server that enables AI agents to interact with the commercetools Composable Commerce platform. It provides tools for managing products, categories, orders, carts, and customer data through secure read and write operations.

MCP Calculator

A modular calculator server built with the MCP SDK that provides basic arithmetic operations (addition, subtraction, multiplication, division) with Chinese language support. Features include calculation history tracking, configuration resources, and decimal calculation prompts with comprehensive error handling.

macOS Calendar MCP Server

A Model Context Protocol server that enables direct integration with macOS Calendar application using AppleScript, allowing users to create, list, and search calendar events without requiring OAuth setup.

EdgeOne Geo MCP Server

Enables AI models to access user geolocation information through EdgeOne Pages Functions, allowing location-aware AI interactions.

Mcp Demos

Repositori kode contoh untuk seri artikel "Dari Prinsip hingga Praktik: Menguasai MCP".

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.

iOS Automation MCP Server

A Model Context Protocol server that enables AI assistants to interact with iOS simulators, perform accessibility testing, manage apps, and automate complex iOS workflows.

Conversation Search MCP Server

Enables comprehensive search and analysis of Claude Code conversation history using full-text search, optional semantic vector search, and conversation management tools. Provides fast SQLite-based indexing with role-based filtering, project organization, and hybrid search capabilities combining keyword and semantic matching.

eBay Analytics MCP Server by CData

This project builds a read-only MCP server. For full read, write, update, delete, and action capabilities and a simplified setup, check out our free CData MCP Server for eBay Analytics (beta): https://www.cdata.com/download/download.aspx?sku=JJZK-V&type=beta

Autonomous Documentation MCP

Automatically analyzes codebases and generates beautiful Mintlify-style documentation with API references, code examples, and changelogs. Keeps documentation synchronized with code changes across multiple programming languages.

ahk-mcp

Server MCP yang mengekspos fungsionalitas AutoHotkey, memungkinkan antarmuka model untuk tugas-tugas otomatisasi di Windows.

SuperMapMCP

MCP Client和Server, 实现shapefile导入到数据库。

Jokes MCP Server

A Model Context Protocol server that provides jokes on demand, allowing users to request different types of jokes (Chuck Norris, Dad jokes, etc.) through Microsoft Copilot Studio or GitHub Copilot.

mcp-get-installed-apps

mcp-get-installed-apps

Docker Manager MCP

Enables AI assistants to manage Docker containers, deploy stacks, and monitor services across multiple Docker hosts from one centralized location. Supports container lifecycle management, Docker Compose operations, and infrastructure orchestration through natural language commands.

Airbnb-Search

An Airbnb search desktop extension that offers advanced filtering features and detailed listing information, suitable for travel planning and listing research.

quickchart-server MCP Server

Cermin dari

MCP Server Zotero Dev

An MCP server that enables AI assistants to build, test, and debug Zotero 7/8 plugins through tools for UI inspection, JavaScript execution, and real-time log monitoring. It integrates with Zotero's Remote Debugging Protocol to provide rich context including screenshots, DOM access, and database querying.

mcp-server-jean

Server Protokol Konteks Model untuk terhubung dengan API Jean

Local Vector Store MCP Server

Enables document search and retrieval using TF-IDF vector similarity across HTML and PDF files. Provides ingest, query, and vector store management capabilities through both HTTP API and MCP stdio interfaces.

MCP Three

Enables working with 3D models by converting GLTF/GLB files into React Three Fiber JSX components and analyzing model structures, hierarchies, and properties for debugging and optimization.

Octagon: MCP For Investment Research

Cermin dari

MCP Basics

A centralized Model Context Protocol server that provides common development tools (like formatting and translation) across all your Cline projects without needing to install them individually.

Vimango MCP Server

Enables Claude to create and organize markdown research notes directly in your local vimango SQLite databases, with support for contexts, folders, and automatic synchronization.

WinCC Unified MCP XT

An MCP server that interfaces with SIEMENS WinCC Unified SCADA systems via GraphQL to manage real-time and historical tag data. It enables AI assistants to browse SCADA objects, read or write tag values, and perform alarm management tasks such as fetching, acknowledging, and resetting alarms.

Civitai MCP Server

Provides AI assistants with access to Civitai's collection of AI models, enabling users to browse, search, and discover AI models through MCP-compatible AI assistants.

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!