Discover Awesome MCP Servers

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).

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.

stdout-mcp-server

Cermin dari

ScreenPilot

MCP server to let LLM take full control on your device by providing screen automation toolkit for controlling and interacting with graphical user interface

Model Context Protocol (sse) servers

Here are a few ways to translate "Model Context Protocol Servers with SSE" into Indonesian, depending on the nuance you want to convey: **Option 1 (Most Literal and General):** * **Server Protokol Konteks Model dengan SSE** This is the most direct translation, keeping the acronyms and technical terms as is. It's suitable if your audience is familiar with these terms in English. **Option 2 (Slightly More Descriptive):** * **Server Protokol Konteks Model Menggunakan SSE** This translates to "Model Context Protocol Servers Using SSE." The "Menggunakan" (using) adds a bit more clarity. **Option 3 (More Explanatory, but Potentially Longer):** * **Server Protokol Konteks Model dengan Implementasi SSE** This translates to "Model Context Protocol Servers with SSE Implementation." This is useful if you want to emphasize that SSE is being *implemented*. **Option 4 (If you want to avoid acronyms, but it might be too verbose):** * **Server Protokol Konteks Model dengan Server-Sent Events** This translates to "Model Context Protocol Servers with Server-Sent Events." This spells out SSE, making it more accessible to those unfamiliar with the acronym. **Which option is best depends on your audience:** * **Technical audience familiar with English acronyms:** Option 1 is fine. * **Technical audience, but you want to be a bit clearer:** Option 2 is a good choice. * **You want to emphasize the implementation aspect:** Option 3 is best. * **Non-technical audience or you want to be very clear:** Option 4 is the most accessible. Therefore, I would recommend **Option 2: Server Protokol Konteks Model Menggunakan SSE** as a good balance between accuracy and clarity for most technical audiences.

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.

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.

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.

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!

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.

Smart Connections MCP Server

Enables semantic search and knowledge graph exploration of Obsidian vaults using Smart Connections embeddings. Provides intelligent note discovery, similarity search, and connection mapping through natural language queries.

Document360 MCP Server

Enables access to Document360 knowledge base content through simple GET operations. Allows searching, browsing categories, and reading articles from Document360 projects using natural language.

PySqlitMCP

Enables comprehensive SQLite database management through natural language including database creation, table operations, data CRUD operations, backup/restore, and CSV import/export functionality. Built on FastMCP framework with PySqlit library for reliable database interactions.

Jokes MCP Server

An MCP server that enables Microsoft Copilot Studio to fetch jokes from multiple sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

AIO-Osint

All in one Osint tools

Everything MCP Server

Enables instant file and folder searching on Windows using Everything's blazing-fast search engine, supporting powerful search syntax including wildcards, regex, size filters, date filters, and comprehensive file information retrieval.

BCB Payment Methods MCP Server

Enables access to Brazil's Central Bank (BCB) Open Data API for payment methods, allowing queries about PIX, card transactions, ATM terminals, interchange rates, and other payment statistics through natural language.

OpenAI Tool Bridge

Jembatan ringan yang membungkus alat bawaan OpenAI (seperti pencarian web dan penerjemah kode) sebagai server Model Context Protocol, memungkinkan penggunaannya dengan Claude dan model lain yang kompatibel dengan MCP.

Todoist GPT MCP

Enables GPT to interact with Todoist tasks and projects through direct API calls or a local SQLite mirror. Supports reading task data via SQL queries, creating/updating/deleting tasks and projects, and synchronizing data between Todoist and the local mirror.

shell-command-mcp

Server MCP untuk menjalankan perintah shell.

MCP Hub

A sophisticated research assistant that orchestrates a 5-step workflow of connected AI agents to provide deep research capabilities including question enhancement, web search, summarization, citation formatting, and result combination.

Remote MCP Server – Professional SEO Checker

A production-ready remote MCP server that performs comprehensive SEO audits, providing structured insights on on-page SEO, technical health, and social metadata without requiring local setup.

mcp-fastify-server

Contoh Server Protokol Konteks Model (MCP)