Discover Awesome MCP Servers

LocaLLama MCP Server

An MCP Server that works with Roo Code/Cline.Bot/Claude Desktop to optimize costs by intelligently routing coding tasks between local LLMs free APIs and paid APIs.

Langfuse Prompt Management MCP Server

Mirror of

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.

MCP-SSE3

created from MCP server demo

Ansible Tower MCP Server

MCP Server for Ansible Tower

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-Wikipedia-API-Server

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

Semantic Scholar API MCP server

There isn't a direct "MCP server" for Semantic Scholar. "MCP" likely refers to a **Message Passing Concurrency** system, which is a programming paradigm. Semantic Scholar, as a large-scale search engine and research platform, uses many different technologies and architectures behind the scenes. It's highly unlikely they would expose a single, specific "MCP server" for public access. However, here's how you can access and interact with Semantic Scholar programmatically to search for papers, which might be what you're trying to achieve: * **Semantic Scholar API:** This is the primary way to programmatically interact with Semantic Scholar. You can use it to search for papers, retrieve paper details, author information, and more. You'll need to make HTTP requests to the API endpoints. * **Documentation:** Start here: [https://api.semanticscholar.org/](https://api.semanticscholar.org/) * **Example (Python):** ```python import requests def search_semantic_scholar(query): url = f"https://api.semanticscholar.org/graph/v1/paper/search?query={query}&fields=title,abstract,authors,year,citationCount,referenceCount,url" response = requests.get(url) if response.status_code == 200: data = response.json() return data else: print(f"Error: {response.status_code}") return None if __name__ == "__main__": search_term = "natural language processing" results = search_semantic_scholar(search_term) if results: print(f"Found {results['total']} results for '{search_term}':") for paper in results['data']: print(f"\nTitle: {paper['title']}") print(f"Year: {paper['year']}") print(f"Authors: {', '.join([author['name'] for author in paper['authors']])}") print(f"Abstract: {paper['abstract']}") print(f"URL: {paper['url']}") print(f"Citation Count: {paper['citationCount']}") print(f"Reference Count: {paper['referenceCount']}") else: print("Search failed.") ``` This Python code uses the `requests` library to make a GET request to the Semantic Scholar API. It searches for papers related to "natural language processing" and prints the title, abstract, authors, year, and URL of each result. You'll need to install the `requests` library: `pip install requests`. Adjust the `fields` parameter in the URL to retrieve different information. * **Libraries/Wrappers:** There might be existing Python or other language libraries that wrap the Semantic Scholar API to make it easier to use. Search on GitHub or package repositories (like PyPI for Python) for "Semantic Scholar API" to see if any are available. Using a library can simplify the process of making API requests and handling the responses. **In summary:** You don't directly interact with an "MCP server" for Semantic Scholar. You use the Semantic Scholar API to search for and retrieve paper information programmatically. The Python example above provides a starting point. --- **Spanish Translation:** No existe un "servidor MCP" directo para Semantic Scholar. "MCP" probablemente se refiere a un sistema de **Concurrencia de Paso de Mensajes** (Message Passing Concurrency), que es un paradigma de programación. Semantic Scholar, como un motor de búsqueda y plataforma de investigación a gran escala, utiliza muchas tecnologías y arquitecturas diferentes entre bastidores. Es muy poco probable que expongan un único "servidor MCP" específico para acceso público. Sin embargo, aquí te explico cómo puedes acceder e interactuar con Semantic Scholar programáticamente para buscar artículos, que podría ser lo que estás intentando lograr: * **API de Semantic Scholar:** Esta es la forma principal de interactuar programáticamente con Semantic Scholar. Puedes usarla para buscar artículos, recuperar detalles de artículos, información de autores y más. Necesitarás hacer solicitudes HTTP a los puntos finales de la API. * **Documentación:** Comienza aquí: [https://api.semanticscholar.org/](https://api.semanticscholar.org/) * **Ejemplo (Python):** ```python import requests def buscar_semantic_scholar(consulta): url = f"https://api.semanticscholar.org/graph/v1/paper/search?query={consulta}&fields=title,abstract,authors,year,citationCount,referenceCount,url" response = requests.get(url) if response.status_code == 200: data = response.json() return data else: print(f"Error: {response.status_code}") return None if __name__ == "__main__": termino_busqueda = "procesamiento del lenguaje natural" resultados = buscar_semantic_scholar(termino_busqueda) if resultados: print(f"Se encontraron {resultados['total']} resultados para '{termino_busqueda}':") for paper in resultados['data']: print(f"\nTítulo: {paper['title']}") print(f"Año: {paper['year']}") print(f"Autores: {', '.join([autor['name'] for autor in paper['authors']])}") print(f"Resumen: {paper['abstract']}") print(f"URL: {paper['url']}") print(f"Conteo de Citas: {paper['citationCount']}") print(f"Conteo de Referencias: {paper['referenceCount']}") else: print("La búsqueda falló.") ``` Este código de Python utiliza la biblioteca `requests` para hacer una solicitud GET a la API de Semantic Scholar. Busca artículos relacionados con "procesamiento del lenguaje natural" e imprime el título, el resumen, los autores, el año y la URL de cada resultado. Necesitarás instalar la biblioteca `requests`: `pip install requests`. Ajusta el parámetro `fields` en la URL para recuperar información diferente. * **Librerías/Wrappers:** Podría haber librerías existentes de Python u otros lenguajes que envuelven la API de Semantic Scholar para facilitar su uso. Busca en GitHub o en repositorios de paquetes (como PyPI para Python) "Semantic Scholar API" para ver si hay alguna disponible. Usar una librería puede simplificar el proceso de hacer solicitudes a la API y manejar las respuestas. **En resumen:** No interactúas directamente con un "servidor MCP" para Semantic Scholar. Utilizas la API de Semantic Scholar para buscar y recuperar información de artículos programáticamente. El ejemplo de Python anterior proporciona un punto de partida.

🤖 MCPServe by @ryaneggz

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

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.

mcp-slack

mcp server for slack

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.

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

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.

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.

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.

Browse your entire Notion workspace, not just one database

Este servidor MCP basado en TypeScript permite a los usuarios gestionar un sistema de notas sencillo mediante la creación y el resumen de notas de texto utilizando el Protocolo de Contexto de Modelos (MCP).

OpenSearch MCP Server

Una implementación de servidor del Protocolo de Contexto de Modelo que permite interacciones en lenguaje natural con clústeres de OpenSearch, permitiendo a los usuarios buscar documentos, analizar índices y administrar clústeres a través de comandos conversacionales sencillos.

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

mcp-server-ntopng

Servidor MCP para el software de monitorización de redes ntopng.

UI-TARS Desktop

A GUI Agent application based on UI-TARS(Vision-Language Model) that allows you to control your computer using natural language.

MCP SSH Server

Mirror of