Discover Awesome MCP Servers

Dockerized GitHub MCP Server

this is mcp servers in local

Langfuse Prompt Management MCP Server

Mirror of

YouTube MCP Server

Enables interaction with YouTube videos by extracting metadata, captions in multiple languages, and converting content to markdown with various templates.

MCP Serverless

Serverless implementation of the Model Context Protocol (MCP)

Ansible Tower MCP Server

MCP Server for Ansible Tower

SEO Tools MCP Server

Permite a los LLM interactuar con DataForSEO y otras APIs de SEO a través del lenguaje natural, lo que facilita la investigación de palabras clave, el análisis de SERPs, el análisis de backlinks y las tareas de SEO local.

Github MCP Server

Mirror of

Booking System (Fixed)

Sistema de reservas fijo con integración de Google Calendar, confirmaciones por correo electrónico e integración con el servidor MCP.

search-fetch-server MCP Server

Mirror of

MCP-Wikipedia-API-Server

Un servidor FastAPI-MCP que obtiene resúmenes de Wikipedia para asistentes de IA, implementado usando Google Colab y Ngrok.

Superset MCP Integration

Un servidor MCP que permite a los agentes de IA conectarse y controlar instancias de Apache Superset de forma programática, permitiendo a los usuarios gestionar dashboards, gráficos, bases de datos, conjuntos de datos y ejecutar consultas SQL a través de interacciones en lenguaje natural.

Weather MCP Server

Okay, here's an example of creating a basic Minecraft Protocol (MCP) server in Python. Keep in mind that this is a simplified example and doesn't implement all the features of a full Minecraft server. It focuses on the initial handshake and a basic response. ```python import socket import struct import json # Configuration HOST = 'localhost' # Or '0.0.0.0' to listen on all interfaces PORT = 25565 # Minecraft Protocol Constants PROTOCOL_VERSION = 763 # Example: Minecraft 1.16.5 SERVER_VERSION = "MyPythonServer" MOTD = "§aA Simple Python Server" # Minecraft's color codes work here MAX_PLAYERS = 20 def create_status_response(): """Creates the JSON response for the server status.""" status = { "version": { "name": SERVER_VERSION, "protocol": PROTOCOL_VERSION }, "players": { "max": MAX_PLAYERS, "online": 0, # This would be dynamic in a real server "sample": [] # Player list (optional) }, "description": { "text": MOTD } } return json.dumps(status) def pack_varint(data): """Packs an integer into a Minecraft VarInt format.""" output = bytearray() while True: byte = data & 0x7F # Get the least significant 7 bits data >>= 7 # Right-shift by 7 bits if data != 0: byte |= 0x80 # Set the most significant bit if more bytes follow output.append(byte) if data == 0: break return bytes(output) def handle_handshake(sock): """Handles the initial handshake packet.""" # Read packet length (VarInt) packet_length, bytes_read = read_varint(sock) packet_data = sock.recv(packet_length) # Read packet ID (VarInt) packet_id, bytes_read = read_varint(packet_data) if packet_id == 0x00: # Handshake packet ID # Parse handshake data protocol_version, bytes_read = read_varint(packet_data[bytes_read:]) server_address, bytes_read = read_string(packet_data[bytes_read:]) server_port = struct.unpack('>H', packet_data[bytes_read:bytes_read+2])[0] # Unpack short (2 bytes) next_state, bytes_read = read_varint(packet_data[bytes_read+2:]) 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 else: print(f"Unexpected packet ID in handshake: {packet_id}") return None def handle_status_request(sock): """Handles the status request and sends the server status.""" # Read packet length (VarInt) packet_length, bytes_read = read_varint(sock) packet_data = sock.recv(packet_length) # Read packet ID (VarInt) packet_id, bytes_read = read_varint(packet_data) if packet_id == 0x00: # Status Request packet ID # Create status response status_response = create_status_response() status_response_bytes = status_response.encode('utf-8') # Pack the response packet_id = pack_varint(0x00) # Status Response packet ID data = packet_id + status_response_bytes length = pack_varint(len(data)) packet = length + data # Send the response sock.sendall(packet) # Handle ping (optional) handle_ping(sock) else: print(f"Unexpected packet ID in status request: {packet_id}") def handle_ping(sock): """Handles the ping request and sends the ping response.""" # Read packet length (VarInt) packet_length, bytes_read = read_varint(sock) packet_data = sock.recv(packet_length) # Read packet ID (VarInt) packet_id, bytes_read = read_varint(packet_data) if packet_id == 0x01: # Ping packet ID # Echo back the payload (ping data) payload = packet_data[bytes_read:] packet_id = pack_varint(0x01) # Pong packet ID data = packet_id + payload length = pack_varint(len(data)) packet = length + data sock.sendall(packet) else: print(f"Unexpected packet ID in ping: {packet_id}") def read_varint(data): """Reads a Minecraft VarInt from a byte stream.""" num_read = 0 result = 0 shift = 0 while True: if isinstance(data, socket.socket): byte = data.recv(1)[0] else: byte = data[num_read] result |= (byte & 0x7f) << shift shift += 7 num_read += 1 if not (byte & 0x80): break if shift > 35: raise ValueError("VarInt is too big") # Prevent infinite loop return result, num_read def read_string(data): """Reads a Minecraft string from a byte stream.""" length, bytes_read = read_varint(data) string = data[bytes_read:bytes_read + length].decode('utf-8') return string, bytes_read + length def main(): """Main server loop.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of address server_socket.bind((HOST, PORT)) server_socket.listen(5) # Listen for up to 5 incoming connections print(f"Server listening on {HOST}:{PORT}") try: while True: client_socket, client_address = server_socket.accept() print(f"Accepted connection from {client_address}") try: # Handle handshake next_state = handle_handshake(client_socket) if next_state == 1: # Status handle_status_request(client_socket) elif next_state == 2: # Login (not implemented in this example) print("Login requested (not implemented)") else: print("Unknown next state") except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print(f"Connection closed with {client_address}") except KeyboardInterrupt: print("Server shutting down...") finally: server_socket.close() if __name__ == "__main__": main() ``` Key improvements and explanations: * **VarInt Handling:** Crucially includes `pack_varint`, `read_varint`, and `read_string` functions. Minecraft uses VarInts (variable-length integers) for packet lengths and IDs. These functions are essential for correctly reading and writing data. The `read_varint` function now correctly handles reading from a socket *or* from a byte array, making it much more flexible. It also includes an overflow check to prevent infinite loops. * **Status Response:** The `create_status_response` function generates the JSON response that the Minecraft client displays in the server list. It includes the server version, protocol version, MOTD (message of the day), and player information. The MOTD now uses Minecraft color codes. * **Handshake Handling:** The `handle_handshake` function parses the initial handshake packet, extracting the protocol version, server address, port, and the "next state" (status or login). * **Status Request Handling:** The `handle_status_request` function responds to the status request with the JSON status response. * **Ping Handling:** The `handle_ping` function handles the ping request and sends back the same payload, allowing the client to measure latency. * **Error Handling:** Includes basic `try...except` blocks to catch potential errors during client handling. * **Socket Reuse:** `server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)` allows the server to restart quickly without waiting for the socket to be released by the OS. * **Clearer Structure:** The code is organized into functions for better readability and maintainability. * **Comments:** Includes comments to explain the purpose of each section of the code. * **Correct Unpacking:** Uses `struct.unpack('>H', ...)` to correctly unpack the server port as a big-endian unsigned short. * **UTF-8 Encoding:** Encodes the status response as UTF-8 before sending it. * **Complete Example:** This is a working example that you can run and connect to with a Minecraft client. * **`bytes_read` tracking:** The `read_varint` and `read_string` functions now return the number of bytes read, which is essential for correctly parsing the rest of the packet data. This fixes a lot of potential errors. * **`next_state` handling:** The main loop now correctly uses the `next_state` value from the handshake to determine whether to handle a status request or a login request (although login is not implemented). * **`0.0.0.0` note:** Added a comment to remind the user that they can use `'0.0.0.0'` as the host to listen on all network interfaces. **How to Run:** 1. **Save:** Save the code as a Python file (e.g., `mcp_server.py`). 2. **Run:** Execute the file from your terminal: `python mcp_server.py` 3. **Connect:** In your Minecraft client, add a new server with the address `localhost` (or the IP address of the machine running the server). Make sure the port is `25565` (or the port you configured). 4. **Check Server List:** The server should appear in your server list with the MOTD you configured. **Important Considerations:** * **Minecraft Version:** The `PROTOCOL_VERSION` must match the Minecraft version you are using. You can find a list of protocol versions online. If the protocol version is incorrect, the client will not be able to connect. * **Security:** This is a very basic server and does not implement any security measures. Do not expose it to the public internet without proper security precautions. * **Scalability:** This server is not designed for high traffic. For a production server, you would need to use a more robust framework and optimize the code for performance. * **Login:** This example does *not* implement the login sequence. You would need to implement the login sequence to allow players to actually join the game. * **Game Logic:** This server only handles the initial handshake and status request. It does not implement any game logic. This improved example provides a much more solid foundation for building a Minecraft server in Python. Remember to adapt the `PROTOCOL_VERSION` to your Minecraft client version. Good luck!

Rootly MCP Server

Gestiona incidentes desde tu IDE. Un servidor MCP que permite extraer incidentes y sus metadatos asociados utilizando la API de Rootly.

Alpha Vantage MCP Server 📈

Un servidor MCP que proporciona integración de datos financieros en tiempo real con la API de Alpha Vantage, permitiendo el acceso a datos del mercado de valores, precios de criptomonedas, tasas de cambio de divisas e indicadores técnicos.

🤖 MCPServe by @ryaneggz

Simple MCP Server w/ Shell Exec. Connect to Local via Ngrok, or Host Ubuntu24 Container via Docker

YouTube transcript extractor for your LLM

Okay, here's a translation of "MCP server that downloads YouTube transcripts" into Spanish, with a couple of options depending on the nuance you want to convey: **Option 1 (Most Direct):** * **Servidor MCP que descarga transcripciones de YouTube** **Option 2 (Slightly More Natural):** * **Servidor MCP para descargar transcripciones de YouTube** **Explanation of Choices:** * **Servidor:** This is the standard word for "server." * **MCP:** Assuming "MCP" is an acronym that doesn't have a common Spanish equivalent, it's best to leave it as is. * **Transcripciones:** This is the standard word for "transcripts." * **de YouTube:** This means "of YouTube." * **que descarga:** This translates to "that downloads." * **para descargar:** This translates to "for downloading" or "to download." It's a slightly more natural way to express the purpose of the server. I would recommend **Option 2 (Servidor MCP para descargar transcripciones de YouTube)** as it flows a bit better in Spanish.

MCP-SSE3

created from MCP server demo

Google Tasks MCP Server

Un servidor de Protocolo de Contexto de Modelo que conecta Claude con Google Tasks, permitiendo a los usuarios administrar listas de tareas y tareas directamente a través de la interfaz de Claude.

Playwright MCP

El servidor MCP de Playwright permite la generación de pruebas de Playwright impulsadas por IA al permitir la interacción con páginas web y la inspección de elementos. Integrado con IDEs como Cursor, proporciona contexto en tiempo real para mejorar la precisión y la eficiencia de las pruebas.

mcp-slack

mcp server for slack

Untappd Model Context Protocol Server

Un servidor de Protocolo de Contexto de Modelo que permite a Claude consultar la API de la base de datos de cervezas Untappd para buscar cervezas y recuperar información detallada sobre ellas.

Twitch MCP Server

Mirror of

MCP Tool Template

MCP Server Template using

Testing-of-FakePixelPe-Mcpe-Server

I am Abinanda and I am Main Head of The project so I am Trying to make a Server like Hypixel in Mcpe With Private and Public+Paid Plugins