Discover Awesome MCP Servers

DataDog MCP Server

Enables AI assistants to interact with DataDog's observability platform through a standardized interface. Supports monitoring infrastructure, managing events, analyzing logs and metrics, and automating operations like alerts and downtimes.

Azure Kusto MCP Server

Um Servidor MCP para Azure Kusto

MCP Authentication Example

Demonstrates OAuth2/OIDC authentication for MCP servers using Asgardeo, with JWT validation and a sample weather tool to showcase secured API access.

build-simple-mcp

Okay, here's a guide on how to build a simple Minecraft Protocol (MCP) server in Python. This will be a very basic server, capable of handling a single client, and will only implement a small subset of the Minecraft protocol. It's intended for learning and experimentation, not for actual gameplay. **Important Considerations:** * **Complexity:** The Minecraft protocol is complex. This example will only cover the bare minimum to get a client to connect and receive a basic status response. * **Security:** This is a simplified example and does *not* include any security measures. Do not expose this server to the public internet. * **Libraries:** We'll use the `socket` library for networking and `struct` for packing and unpacking data. You might consider using a more robust library like `nbt` for handling NBT data in a real server. * **Protocol Version:** This example will target a specific Minecraft protocol version. You'll need to adjust the code if you want to support different versions. I'll use a relatively recent version (e.g., 763 for 1.17.1), but you should check the Minecraft wiki for the correct version for your client. * **Error Handling:** This example will have minimal error handling for brevity. A real server needs robust error handling. **Code (Python):** ```python import socket import struct import json # Configuration HOST = 'localhost' # Listen on all interfaces PORT = 25565 PROTOCOL_VERSION = 763 # Minecraft 1.17.1 SERVER_VERSION_NAME = "My Simple Server" MAX_PLAYERS = 20 MOTD = "§aA Simple Minecraft Server" # Use Minecraft color codes # Helper functions for reading and writing Minecraft protocol data def read_varint(sock): result = 0 shift = 0 while True: byte = sock.recv(1)[0] result |= (byte & 0x7F) << shift shift += 7 if not (byte & 0x80): break return result def write_varint(sock, data): while True: byte = data & 0x7F data >>= 7 if data != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if data == 0: break def write_string(sock, data): encoded_data = data.encode('utf-8') write_varint(sock, len(encoded_data)) sock.send(encoded_data) def read_string(sock): length = read_varint(sock) data = sock.recv(length) return data.decode('utf-8') # Server status response def get_status_response(): status = { "version": { "name": SERVER_VERSION_NAME, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": 0, "sample": [] # Add player samples if you want }, "description": { "text": MOTD } } return json.dumps(status) # Handle the handshake def handle_handshake(sock): protocol_version = read_varint(sock) server_address = read_string(sock) server_port = struct.unpack(">H", sock.recv(2))[0] # Big-endian unsigned short next_state = read_varint(sock) print(f"Protocol Version: {protocol_version}") print(f"Server Address: {server_address}") print(f"Server Port: {server_port}") print(f"Next State: {next_state}") return next_state # Handle status requests def handle_status(sock): # Expect an empty packet (request) packet_length = read_varint(sock) packet_id = sock.recv(1)[0] if packet_id == 0x00: # Send the status response status_response = get_status_response() status_response_bytes = status_response.encode('utf-8') packet = struct.pack("b", 0x00) + status_response_bytes write_varint(sock, len(packet)) sock.send(packet) # Handle ping packet_length = read_varint(sock) packet_id = sock.recv(1)[0] if packet_id == 0x01: ping_payload = sock.recv(8) # 8-byte payload packet = struct.pack("b", 0x01) + ping_payload write_varint(sock, len(packet)) sock.send(packet) else: print(f"Unexpected packet ID: {packet_id}") # Main server loop def main(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow address reuse server_socket.bind((HOST, PORT)) server_socket.listen(1) # Only allow one connection print(f"Server listening on {HOST}:{PORT}") while True: client_socket, client_address = server_socket.accept() print(f"Client connected from {client_address}") try: # Handshake next_state = handle_handshake(client_socket) if next_state == 1: # Status handle_status(client_socket) elif next_state == 2: # Login (not implemented in this example) print("Login requested (not implemented)") else: print(f"Unknown next state: {next_state}") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print("Client disconnected") if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries. 2. **Configuration:** Sets up server parameters like host, port, protocol version, MOTD, etc. **Crucially, make sure `PROTOCOL_VERSION` matches the version your Minecraft client is using.** 3. **Helper Functions:** * `read_varint(sock)`: Reads a variable-length integer (VarInt) from the socket. VarInts are used extensively in the Minecraft protocol. * `write_varint(sock, data)`: Writes a VarInt to the socket. * `write_string(sock, data)`: Writes a string to the socket, prefixed by its length as a VarInt. * `read_string(sock)`: Reads a string from the socket, reading the length as a VarInt first. 4. **`get_status_response()`:** Creates the JSON response that the server sends to the client when it requests the server status. This includes the server version, player count, and MOTD. The MOTD uses Minecraft color codes (e.g., `§a` for green). 5. **`handle_handshake(sock)`:** Handles the initial handshake packet from the client. It reads the protocol version, server address, port, and the "next state" (1 for status, 2 for login). It prints this information to the console. 6. **`handle_status(sock)`:** Handles the status request from the client. It expects an empty packet (0x00) and then sends the status response. It also handles the ping request (0x01) by echoing back the ping payload. 7. **`main()`:** * Creates a socket and binds it to the specified host and port. * Listens for incoming connections. * Accepts a client connection. * Calls `handle_handshake()` to process the handshake. * Based on the "next state" from the handshake, calls `handle_status()` or prints a message if login is requested (which is not implemented). * Closes the client socket. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Open a terminal or command prompt and run the script: `python mcp_server.py` 3. **Connect with Minecraft:** * Start your Minecraft client. * Go to "Multiplayer". * Click "Add Server". * Enter a server name (e.g., "My Server"). * Enter the server address as `localhost:25565` (or the IP address and port you configured). * **Important:** You may need to manually specify the Minecraft version in your client's installation settings to match the `PROTOCOL_VERSION` in the server code. If the versions don't match, the client will refuse to connect. You can often do this by creating a new installation profile in the Minecraft launcher. 4. **Observe:** You should see the server in your server list. When you hover over it, you should see the MOTD and player count. If you can't see the server, double-check the following: * The server is running. * The server address and port are correct in the Minecraft client. * The `PROTOCOL_VERSION` in the server code matches the Minecraft client version. * Firewall rules are not blocking the connection. **Limitations and Next Steps:** * **No Login:** This server doesn't handle player login. * **No World:** There's no world generation or game logic. * **Single Client:** It only supports one client at a time. * **Basic Protocol:** It only implements a small part of the Minecraft protocol. * **Error Handling:** Needs much better error handling. To build a more complete server, you would need to: * Implement the login sequence (encryption, authentication). * Generate or load a world. * Handle player movement, block updates, and other game events. * Implement a more robust networking architecture to handle multiple clients. * Use a library like `nbt` to handle NBT data (used for storing world data, player data, etc.). * Add security measures to prevent cheating and attacks. This example provides a starting point for understanding the basics of the Minecraft protocol and building your own server. Good luck!

AutoBrowser MCP

Autobrowser MCP is a Model Context Provider (MCP) server that allows AI applications to control your browser

MCP4GVA

Enables access to GVA GIS (Generalitat Valenciana) geographic data through ArcGIS REST API, allowing queries, filtering, and exporting of land activity information in the Valencian Community.

MCP Add Server

A minimal Model Context Protocol server that provides a simple add(a, b) tool for computing the sum of two numbers.

WeiWanMcpServer

Servidor Mcp Privado

Slack MCP Server

A server implementing Model Context Protocol that enables AI assistants to interact with Slack API through a standardized interface, providing tools for messaging, channel management, user information retrieval, and more.

富途 MCP 服务器 (Futu MCP Server)

Exposes Futu API client capabilities as an MCP (Model Context Protocol) tool, allowing AI assistants to access stock data from Futu through a standardized interface.

Oracle MCP Server by CData

Oracle MCP Server by CData

mcp-confluence

Um servidor de contexto de modelo que fornece prompts que podem ser usados como comandos de barra (slash commands) para clientes como o Zed Editor, a fim de adicionar o conteúdo da página como contexto ao assistente de IA.

Gradle Tomcat MCP Server

Enables management of Gradle-based Tomcat applications with capabilities for starting, stopping, restarting processes and querying application logs.

Slidespeak

Okay, I understand. You want to know how to generate PowerPoint presentations using the Slidespeak API. Here's a breakdown of how to do that, along with important considerations: **Understanding the Slidespeak API** The Slidespeak API allows you to programmatically create and manipulate PowerPoint presentations. You'll typically interact with it using HTTP requests (like POST, GET, PUT, DELETE) to send instructions and receive responses. **General Steps to Generate a PowerPoint Presentation** 1. **Sign Up and Get an API Key:** * You'll need to create an account on the Slidespeak platform and obtain an API key. This key is essential for authenticating your requests. The Slidespeak documentation will guide you through this process. 2. **Choose a Programming Language and Library:** * Select a programming language you're comfortable with (e.g., Python, JavaScript, Java, PHP, Ruby). * Use an HTTP client library in your chosen language to make requests to the Slidespeak API. Examples: * **Python:** `requests` * **JavaScript:** `fetch`, `axios` * **Java:** `HttpClient` (from Apache HttpComponents) * **PHP:** `curl` * **Ruby:** `net/http` 3. **Understand the Slidespeak API Endpoints and Data Structures:** * **Crucially, consult the Slidespeak API documentation.** This is the most important step. The documentation will tell you: * The base URL for the API. * The specific endpoints for creating presentations, adding slides, adding text, images, etc. * The format of the data you need to send in your requests (usually JSON). * The format of the responses you'll receive. * Authentication methods (usually using your API key in a header). 4. **Construct Your API Requests:** * **Create a Presentation:** Typically, you'll start by making a POST request to an endpoint like `/presentations` or `/createPresentation`. You might provide a title for the presentation in the request body. * **Add Slides:** Next, you'll add slides to the presentation. This usually involves a POST request to an endpoint like `/presentations/{presentationId}/slides` or `/addSlide`. You might specify a layout for the slide (e.g., title slide, title and content, blank). * **Add Content to Slides:** For each slide, you'll add text, images, shapes, etc. This will involve POST or PUT requests to endpoints like `/slides/{slideId}/text`, `/slides/{slideId}/image`, `/slides/{slideId}/shape`. You'll need to provide the content (text, image URL, shape type, etc.) and positioning information (coordinates, size). * **Set Formatting:** You can usually control the formatting of text, shapes, and other elements (font, color, size, alignment, etc.) through the API. The Slidespeak documentation will detail the available formatting options. * **Download the Presentation:** Finally, you'll make a GET request to an endpoint like `/presentations/{presentationId}/download` or `/presentations/{presentationId}.pptx` to download the generated PowerPoint file. 5. **Handle API Responses:** * Check the HTTP status code of each response. A status code of 200 (OK) usually indicates success. Other status codes (e.g., 400 Bad Request, 401 Unauthorized, 500 Internal Server Error) indicate errors. * Parse the response body (usually JSON) to extract any relevant information, such as the ID of the created presentation or slide. * Implement error handling to gracefully handle API errors. **Example (Conceptual - Python with `requests`)** ```python import requests import json API_KEY = "YOUR_SLIDESPEAK_API_KEY" # Replace with your actual API key BASE_URL = "https://api.slidespeak.com/v1" # Replace with the actual Slidespeak API base URL def create_presentation(title): url = f"{BASE_URL}/presentations" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } data = {"title": title} response = requests.post(url, headers=headers, data=json.dumps(data)) if response.status_code == 201: # Assuming 201 Created is the success code return response.json()["id"] # Assuming the response contains the presentation ID else: print(f"Error creating presentation: {response.status_code} - {response.text}") return None def add_slide(presentation_id, layout="title_and_content"): url = f"{BASE_URL}/presentations/{presentation_id}/slides" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } data = {"layout": layout} response = requests.post(url, headers=headers, data=json.dumps(data)) if response.status_code == 201: return response.json()["id"] # Assuming the response contains the slide ID else: print(f"Error adding slide: {response.status_code} - {response.text}") return None def add_text_to_slide(slide_id, text, x, y, width, height): url = f"{BASE_URL}/slides/{slide_id}/text" headers = { "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json" } data = { "text": text, "x": x, "y": y, "width": width, "height": height } response = requests.post(url, headers=headers, data=json.dumps(data)) if response.status_code == 200: return True else: print(f"Error adding text: {response.status_code} - {response.text}") return False def download_presentation(presentation_id, filename="presentation.pptx"): url = f"{BASE_URL}/presentations/{presentation_id}/download" # Or maybe f"{BASE_URL}/presentations/{presentation_id}.pptx" headers = { "Authorization": f"Bearer {API_KEY}" } response = requests.get(url, headers=headers, stream=True) # stream=True for large files if response.status_code == 200: with open(filename, "wb") as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) print(f"Presentation downloaded to {filename}") return True else: print(f"Error downloading presentation: {response.status_code} - {response.text}") return False # Example Usage presentation_id = create_presentation("My Awesome Presentation") if presentation_id: slide_id = add_slide(presentation_id) if slide_id: add_text_to_slide(slide_id, "Hello, Slidespeak!", 100, 100, 500, 50) download_presentation(presentation_id) ``` **Important Considerations and Best Practices:** * **Rate Limiting:** Be aware of the Slidespeak API's rate limits. If you exceed the limits, your requests may be throttled or blocked. Implement error handling and retry mechanisms to deal with rate limiting. * **Error Handling:** Implement robust error handling to catch API errors and handle them gracefully. Log errors for debugging purposes. * **Data Validation:** Validate the data you're sending to the API to ensure it's in the correct format and within the allowed ranges. * **Asynchronous Operations:** For complex presentations, consider using asynchronous operations to avoid blocking your main thread. This is especially important for web applications. * **API Documentation is Key:** I cannot stress this enough. The Slidespeak API documentation is your bible. Refer to it constantly. The example code above is *illustrative* and *will not work* without the correct API endpoints and data structures from the Slidespeak documentation. * **Security:** Protect your API key. Do not hardcode it directly into your code, especially if you're sharing your code publicly. Use environment variables or a configuration file to store your API key. * **Testing:** Thoroughly test your code to ensure it generates presentations correctly and handles errors gracefully. **In summary, to use the Slidespeak API, you need to:** 1. **Get an API key.** 2. **Study the Slidespeak API documentation.** 3. **Use a programming language and HTTP client library to make requests to the API.** 4. **Construct your requests according to the API documentation.** 5. **Handle the API responses and errors.** Good luck! Let me know if you have more specific questions after reviewing the Slidespeak API documentation.

MyMCP Prompt

MyMCP Prompt é uma ferramenta para gerar servidores Model Context Protocol (MCP) a partir de descrições em linguagem natural. Este MVP usa a API Google Gemini para converter descrições do usuário em servidores MCP Python funcionais com configurações JSON correspondentes.

Remote MCP Server (Authless)

A tool for deploying an authentication-free Model Context Protocol server on Cloudflare Workers that can be connected to AI clients like Claude Desktop or the Cloudflare AI Playground.

Shopify Python MCP Server

Servidor MCP que se integra com a API da Shopify, permitindo que usuários do Claude Desktop recuperem e manipulem informações de produtos de lojas Shopify.

Task Trellis MCP

An MCP server for Task Trellis that provides tools for AI coding agents to manage tasks, currently featuring a simple hello_world demonstration tool.

Cloudflare Playwright MCP

A server that enables AI assistants to control a browser through tools, allowing them to perform web automation tasks like navigation, typing, clicking, and taking screenshots.

ABSD DevOps MCP Server

Enables secure local filesystem operations and interactive terminal sessions for AI assistants. Provides 12 tools for file management, directory operations, code searching, and running interactive REPLs with security protections.

Agentic MCP Server

Enables AI-driven orchestration of GitHub development workflows including automated issue analysis, code generation, code review, and PR creation through multiple specialized agents. Integrates with GitHub Actions to automate the complete development process from issue to pull request.

Self-hosted LLM MCP Server

Enables interaction with self-hosted LLM models via Ollama and Supabase database operations. Supports text generation, SQL queries, and data storage/retrieval through natural language commands.

MCP Dependencies Installer

Instalar todas as dependências para o servidor MCP.

Webshot MCP

Enables taking screenshots of web pages with support for multiple devices (desktop, mobile, tablet), custom dimensions, full-page capture, and various image formats. Built with Playwright for reliable web page rendering and screenshot generation.

AgenticRAG MCP Server

An intelligent codebase processing server that provides agentic RAG capabilities for code repositories, enabling semantic search and contextual understanding through self-evaluating retrieval loops.

Jokes MCP Server

A Model Context Protocol server that provides joke delivery functionality, allowing users to request various types of jokes (Chuck Norris, Dad jokes, etc.) through Microsoft Copilot Studio or Visual Studio Code.

ORAS MCP Server

Enables users to interact with container registries through the ORAS CLI, providing information about container images, platforms, and signatures via natural language queries.

Jira JQL Tool for Claude

Ferramentas MCP Simples e Práticas