Discover Awesome MCP Servers

dbt Semantic Layer MCP Server

Espejo de

mcp-servers

A collection of MCP server tools in Typescript

Databricks MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los LLM interactuar con los espacios de trabajo de Databricks a través del lenguaje natural, permitiendo la ejecución de consultas SQL y operaciones de gestión de trabajos.

CoinGecko API Server MCP

Mirror of

Azure AI Agent Service + Azure AI Search MCP Server

Espejo de

Whisper_King

Repository created by MCP server

Omi Uber Mcp

An MCP server for Omi devices calling uber

MCP Server

Here are a few options for translating "Test MCP server that can do several things" into Spanish, depending on the nuance you want to convey: **Option 1 (Most straightforward):** * **Servidor MCP de prueba que puede hacer varias cosas.** * This is a direct translation and is perfectly understandable. **Option 2 (Emphasizing functionality):** * **Servidor MCP de prueba con múltiples funcionalidades.** * This emphasizes the server's ability to perform multiple functions. **Option 3 (Using "varias funciones" instead of "varias cosas"):** * **Servidor MCP de prueba que puede realizar varias funciones.** * Similar to option 1, but using "funciones" (functions) which might be slightly more technical. **Option 4 (More formal):** * **Servidor MCP de prueba capaz de realizar diversas tareas.** * "Diversas tareas" (various tasks) is a more formal way of saying "several things." **Which one is best depends on the context. If you want a simple, clear translation, Option 1 is a good choice. If you want to emphasize the server's capabilities, Option 2 or 3 might be better.**

Share MCP - Model Context Protocol 导航站

Share MCP es un sitio de navegación centrado en el Protocolo de Contexto de Modelos (MCP). Ofrece una amplia gama de recursos, herramientas y servicios relacionados con MCP, clasificados para ayudar a los desarrolladores a encontrar rápidamente las soluciones MCP que necesitan.

mcp-server-poc-projects

Simple POC Projects w/ stdio transports for Desktop

MCP Documentation Search Server

🔍 FastMCP-powered documentation search engine that provides unified access to multiple framework docs (Next.js, Tailwind, Framer Motion, etc.) with intelligent name resolution and async processing.

MCP Server Office

Un servidor que proporciona herramientas para leer, escribir y editar archivos de Microsoft Word (docx) a través del Protocolo de Contexto de Modelo, permitiendo operaciones como la lectura completa del documento, la creación de contenido, la edición de párrafos específicos y la inserción de texto.

Maven Dependencies MCP Server

Mirror of

MCP Server Example

Okay, here's a basic template for an MCP (Minecraft Protocol) server that can be integrated with Cursor and leverage AI tools like Claude-3.7-sonnet for things like weather information retrieval. This is a simplified example and will require further development to be fully functional and robust. **Conceptual Overview:** 1. **MCP Server Core:** Handles the basic Minecraft protocol, player connections, and command processing. 2. **Cursor Integration:** This part focuses on how you'd interact with Cursor's API (assuming you have access and understand how to use it). The key is to send relevant data (e.g., player commands, location) to Cursor and receive AI-generated responses. 3. **AI Interaction (Claude-3.7-sonnet):** This is where you'd use Cursor to send prompts to Claude-3.7-sonnet to get weather information. 4. **Response Handling:** The server receives the AI's response and formats it for display to the player in Minecraft. **Code Structure (Python - Example):** ```python import socket import struct import json import threading # Assuming you have a Cursor API library or know how to make HTTP requests # to the Cursor API. Replace with your actual Cursor interaction code. # import cursor_api # Hypothetical Cursor API library import requests # Configuration HOST = '0.0.0.0' # Listen on all interfaces PORT = 25565 # Default Minecraft port CURSOR_API_ENDPOINT = "YOUR_CURSOR_API_ENDPOINT" # Replace with the actual endpoint CURSOR_API_KEY = "YOUR_CURSOR_API_KEY" # Replace with your actual API key # --- Minecraft Protocol Functions (Simplified) --- def read_varint(sock): """Reads a Minecraft VarInt from the socket.""" result = 0 num_read = 0 while True: read = sock.recv(1) if not read: return None # Connection closed byte = ord(read) value = (byte & 0x7F) result |= (value << (7 * num_read)) num_read += 1 if num_read > 5: raise ValueError("VarInt is too big") if (byte & 0x80) == 0: break return result def write_varint(sock, value): """Writes a Minecraft VarInt to the socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if value == 0: break def send_packet(sock, packet_id, data): """Sends a Minecraft packet.""" packet = struct.pack("b", packet_id) + data write_varint(sock, len(packet)) sock.sendall(packet) def handle_handshake(sock): """Handles the initial handshake.""" protocol_version = read_varint(sock) server_address_length = read_varint(sock) server_address = sock.recv(server_address_length).decode('utf-8') server_port = struct.unpack(">H", sock.recv(2))[0] next_state = read_varint(sock) print(f"Handshake: Protocol {protocol_version}, Address {server_address}:{server_port}, State {next_state}") if next_state == 1: # Status handle_status(sock) elif next_state == 2: # Login handle_login(sock) else: print("Unknown next state") def handle_status(sock): """Handles the status request.""" # Receive status request (empty packet) packet_length = read_varint(sock) packet_id = struct.unpack("b", sock.recv(1))[0] # Send status response status = { "version": {"name": "My AI Server", "protocol": 757}, # Example protocol version "players": {"max": 10, "online": 0, "sample": []}, "description": {"text": "An AI-Powered Minecraft Server"} } status_json = json.dumps(status) status_bytes = status_json.encode('utf-8') status_packet = struct.pack("b", 0x00) + struct.pack(">i", len(status_bytes)) + status_bytes write_varint(sock, len(status_packet)) sock.sendall(status_packet) # Handle ping packet_length = read_varint(sock) packet_id = struct.unpack("b", sock.recv(1))[0] ping_payload = sock.recv(8) # Ping payload is 8 bytes ping_packet = struct.pack("b", 0x01) + ping_payload write_varint(sock, len(ping_packet)) sock.sendall(ping_packet) def handle_login(sock): """Handles the login process.""" packet_length = read_varint(sock) packet_id = struct.unpack("b", sock.recv(1))[0] username_length = read_varint(sock) username = sock.recv(username_length).decode('utf-8') print(f"Login: Username {username}") # Send Login Success uuid = "00000000-0000-0000-0000-000000000000" # Dummy UUID login_success_data = struct.pack(">i", len(uuid)) + uuid.encode('utf-8') + struct.pack(">i", len(username)) + username.encode('utf-8') send_packet(sock, 0x02, login_success_data) # Send Join Game (Example) join_game_data = struct.pack(">i", 0) # Entity ID join_game_data += struct.pack("b", 0) # Gamemode join_game_data += struct.pack("b", 0) # Dimension join_game_data += struct.pack("b", 0) # Difficulty join_game_data += struct.pack("b", 1) # Max Players join_game_data += b"" # Level Type (empty string) join_game_data += struct.pack("?", False) # Reduced Debug Info send_packet(sock, 0x26, join_game_data) # Start playing (example - send a chat message) send_chat_message(sock, "Welcome to the AI Server!") return username def send_chat_message(sock, message): """Sends a chat message to the client.""" chat_data = struct.pack(">i", len(message)) + message.encode('utf-8') chat_data += struct.pack("b", 0) # Position (0: chat box, 1: system message, 2: game info) send_packet(sock, 0x0F, chat_data) # --- AI Interaction Functions --- def get_weather_from_ai(location): """Retrieves weather information from the AI (Claude-3.7-sonnet).""" try: # Construct the prompt for Claude prompt = f"What is the current weather in {location}? Provide a brief summary." # Send the prompt to Cursor API headers = { "Authorization": f"Bearer {CURSOR_API_KEY}", "Content-Type": "application/json" } data = { "model": "claude-3.5-sonnet", # Or the correct model name "messages": [{"role": "user", "content": prompt}] } response = requests.post(CURSOR_API_ENDPOINT, headers=headers, json=data) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) response_json = response.json() ai_response = response_json["choices"][0]["message"]["content"] # Adjust based on Cursor's response format return ai_response except requests.exceptions.RequestException as e: print(f"Error communicating with Cursor API: {e}") return "Error: Could not retrieve weather information." except (KeyError, IndexError) as e: print(f"Error parsing Cursor API response: {e}") return "Error: Could not understand weather information." # --- Command Handling --- def handle_chat_message(sock, message): """Handles chat messages from the client.""" if message.startswith("/weather"): try: _, location = message.split(" ", 1) # Split into command and location weather_info = get_weather_from_ai(location) send_chat_message(sock, f"Weather in {location}: {weather_info}") except ValueError: send_chat_message(sock, "Usage: /weather <location>") else: send_chat_message(sock, f"You said: {message}") def process_client(sock, address): """Handles communication with a single client.""" try: handle_handshake(sock) username = handle_login(sock) # Main game loop (simplified) while True: packet_length = read_varint(sock) if packet_length is None: break # Connection closed packet_id = struct.unpack("b", sock.recv(1))[0] if packet_id == 0x03: # Chat Message message_length = read_varint(sock) message = sock.recv(message_length).decode('utf-8') handle_chat_message(sock, message) else: # Ignore other packets for this example sock.recv(packet_length - 1) # Consume the rest of the packet except Exception as e: print(f"Error handling client: {e}") finally: print(f"Closing connection with {address}") sock.close() # --- Server Setup --- def main(): """Main server function.""" 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 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}") client_thread = threading.Thread(target=process_client, args=(client_socket, client_address)) client_thread.start() except KeyboardInterrupt: print("Shutting down server...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Explanation and Key Points:** * **Minecraft Protocol:** The code implements a very basic subset of the Minecraft protocol. You'll need to study the protocol documentation for full functionality. The `read_varint`, `write_varint`, and `send_packet` functions are crucial for handling the variable-length integers used in the protocol. * **Handshake, Status, Login:** The `handle_handshake`, `handle_status`, and `handle_login` functions handle the initial connection phases. The server sends a dummy status response and a login success packet. * **Chat Messages:** The `handle_chat_message` function demonstrates how to receive and process chat messages from the client. It includes a `/weather` command. * **AI Integration (`get_weather_from_ai`):** * This is the core of the AI integration. It constructs a prompt for Claude-3.7-sonnet, sends it to the Cursor API, and parses the response. * **Important:** You'll need to replace `"YOUR_CURSOR_API_ENDPOINT"` and `"YOUR_CURSOR_API_KEY"` with your actual Cursor API credentials. * The code uses the `requests` library to make HTTP requests to the Cursor API. Make sure you have it installed (`pip install requests`). * The code assumes a specific JSON structure for the Cursor API response. You'll need to adjust the parsing logic (`response_json["choices"][0]["message"]["content"]`) based on the actual response format. * Error handling is included to catch potential issues with the API request or response parsing. * **Threading:** The server uses threads to handle multiple client connections concurrently. * **Error Handling:** Basic error handling is included, but you'll need to add more robust error handling for a production-ready server. * **Simplifications:** * This is a highly simplified example. It doesn't implement many features of a real Minecraft server. * It doesn't handle player movement, world generation, or other game logic. * The Minecraft protocol implementation is incomplete. * **Security:** This code is not secure. It's vulnerable to various attacks. You'll need to implement proper security measures for a production server. **How to Use with Cursor:** 1. **Set up Cursor:** Make sure you have a Cursor account and have access to the Cursor API. 2. **Install `requests`:** `pip install requests` 3. **Replace Placeholders:** Replace `"YOUR_CURSOR_API_ENDPOINT"` and `"YOUR_CURSOR_API_KEY"` with your actual Cursor API credentials. 4. **Run the Server:** Run the Python script. 5. **Connect with Minecraft:** Start your Minecraft client and connect to `localhost:25565`. 6. **Use the `/weather` command:** In the Minecraft chat, type `/weather <location>` (e.g., `/weather London`). The server should send a request to Cursor, get the weather information from Claude-3.7-sonnet, and display it in the chat. **Further Development:** * **Complete Minecraft Protocol:** Implement the full Minecraft protocol for a more functional server. * **World Generation:** Implement world generation to create a playable world. * **Player Movement:** Handle player movement and position updates. * **Game Logic:** Implement game logic, such as item handling, entity interactions, and more. * **Database Integration:** Use a database to store player data, world data, and other persistent information. * **Security:** Implement security measures to protect the server from attacks. * **Configuration:** Use a configuration file to store server settings. * **Logging:** Implement logging to track server activity and errors. * **More AI Interactions:** Explore other ways to integrate AI into the server, such as: * Generating quests. * Creating dynamic events. * Providing personalized advice to players. * Generating custom items. **Important Considerations:** * **Cursor API Usage:** Be mindful of Cursor's API usage limits and pricing. Excessive use of the API can incur costs. * **AI Model Limitations:** Claude-3.7-sonnet (or any AI model) has limitations. It may not always provide accurate or relevant information. You'll need to handle these limitations gracefully. * **Prompt Engineering:** The quality of the AI's responses depends heavily on the prompts you provide. Experiment with different prompts to get the best results. This template provides a starting point for building an AI-powered Minecraft server. Remember that it requires significant further development to become a fully functional and robust server. Good luck! **Spanish Translation:** Aquí tienes una plantilla básica para un servidor MCP (Minecraft Protocol) que se puede integrar con Cursor y aprovechar herramientas de IA como Claude-3.7-sonnet para cosas como la recuperación de información meteorológica. Este es un ejemplo simplificado y requerirá un mayor desarrollo para ser completamente funcional y robusto. **Descripción General Conceptual:** 1. **Núcleo del Servidor MCP:** Maneja el protocolo básico de Minecraft, las conexiones de los jugadores y el procesamiento de comandos. 2. **Integración con Cursor:** Esta parte se centra en cómo interactuarías con la API de Cursor (asumiendo que tienes acceso y entiendes cómo usarla). La clave es enviar datos relevantes (por ejemplo, comandos del jugador, ubicación) a Cursor y recibir respuestas generadas por IA. 3. **Interacción con la IA (Claude-3.7-sonnet):** Aquí es donde usarías Cursor para enviar prompts a Claude-3.7-sonnet para obtener información meteorológica. 4. **Manejo de Respuestas:** El servidor recibe la respuesta de la IA y la formatea para mostrarla al jugador en Minecraft. **Estructura del Código (Python - Ejemplo):** ```python import socket import struct import json import threading # Asumiendo que tienes una biblioteca de la API de Cursor o sabes cómo hacer peticiones HTTP # a la API de Cursor. Reemplaza con tu código de interacción con Cursor real. # import cursor_api # Biblioteca hipotética de la API de Cursor import requests # Configuración HOST = '0.0.0.0' # Escuchar en todas las interfaces PORT = 25565 # Puerto predeterminado de Minecraft CURSOR_API_ENDPOINT = "TU_ENDPOINT_DE_LA_API_DE_CURSOR" # Reemplaza con el endpoint real CURSOR_API_KEY = "TU_CLAVE_DE_LA_API_DE_CURSOR" # Reemplaza con tu clave de API real # --- Funciones del Protocolo de Minecraft (Simplificado) --- def read_varint(sock): """Lee un VarInt de Minecraft del socket.""" result = 0 num_read = 0 while True: read = sock.recv(1) if not read: return None # Conexión cerrada byte = ord(read) value = (byte & 0x7F) result |= (value << (7 * num_read)) num_read += 1 if num_read > 5: raise ValueError("VarInt es demasiado grande") if (byte & 0x80) == 0: break return result def write_varint(sock, value): """Escribe un VarInt de Minecraft en el socket.""" while True: byte = value & 0x7F value >>= 7 if value != 0: byte |= 0x80 sock.send(struct.pack("B", byte)) if value == 0: break def send_packet(sock, packet_id, data): """Envía un paquete de Minecraft.""" packet = struct.pack("b", packet_id) + data write_varint(sock, len(packet)) sock.sendall(packet) def handle_handshake(sock): """Maneja el handshake inicial.""" protocol_version = read_varint(sock) server_address_length = read_varint(sock) server_address = sock.recv(server_address_length).decode('utf-8') server_port = struct.unpack(">H", sock.recv(2))[0] next_state = read_varint(sock) print(f"Handshake: Protocolo {protocol_version}, Dirección {server_address}:{server_port}, Estado {next_state}") if next_state == 1: # Status handle_status(sock) elif next_state == 2: # Login handle_login(sock) else: print("Estado desconocido") def handle_status(sock): """Maneja la solicitud de estado.""" # Recibe la solicitud de estado (paquete vacío) packet_length = read_varint(sock) packet_id = struct.unpack("b", sock.recv(1))[0] # Envía la respuesta de estado status = { "version": {"name": "Mi Servidor IA", "protocol": 757}, # Ejemplo de versión de protocolo "players": {"max": 10, "online": 0, "sample": []}, "description": {"text": "Un Servidor de Minecraft Impulsado por IA"} } status_json = json.dumps(status) status_bytes = status_json.encode('utf-8') status_packet = struct.pack("b", 0x00) + struct.pack(">i", len(status_bytes)) + status_bytes write_varint(sock, len(status_packet)) sock.sendall(status_packet) # Maneja el ping packet_length = read_varint(sock) packet_id = struct.unpack("b", sock.recv(1))[0] ping_payload = sock.recv(8) # La carga útil del ping es de 8 bytes ping_packet = struct.pack("b", 0x01) + ping_payload write_varint(sock, len(ping_packet)) sock.sendall(ping_packet) def handle_login(sock): """Maneja el proceso de inicio de sesión.""" packet_length = read_varint(sock) packet_id = struct.unpack("b", sock.recv(1))[0] username_length = read_varint(sock) username = sock.recv(username_length).decode('utf-8') print(f"Login: Nombre de usuario {username}") # Envía Login Success uuid = "00000000-0000-0000-0000-000000000000" # UUID ficticio login_success_data = struct.pack(">i", len(uuid)) + uuid.encode('utf-8') + struct.pack(">i", len(username)) + username.encode('utf-8') send_packet(sock, 0x02, login_success_data) # Envía Join Game (Ejemplo) join_game_data = struct.pack(">i", 0) # ID de la entidad join_game_data += struct.pack("b", 0) # Modo de juego join_game_data += struct.pack("b", 0) # Dimensión join_game_data += struct.pack("b", 0) # Dificultad join_game_data += struct.pack("b", 1) # Jugadores máximos join_game_data += b"" # Tipo de nivel (cadena vacía) join_game_data += struct.pack("?", False) # Información de depuración reducida send_packet(sock, 0x26, join_game_data) # Comienza a jugar (ejemplo - envía un mensaje de chat) send_chat_message(sock, "¡Bienvenido al Servidor IA!") return username def send_chat_message(sock, message): """Envía un mensaje de chat al cliente.""" chat_data = struct.pack(">i", len(message)) + message.encode('utf-8') chat_data += struct.pack("b", 0) # Posición (0: cuadro de chat, 1: mensaje del sistema, 2: información del juego) send_packet(sock, 0x0F, chat_data) # --- Funciones de Interacción con la IA --- def get_weather_from_ai(location): """Recupera información meteorológica de la IA (Claude-3.7-sonnet).""" try: # Construye el prompt para Claude prompt = f"¿Cuál es el clima actual en {location}? Proporciona un breve resumen." # Envía el prompt a la API de Cursor headers = { "Authorization": f"Bearer {CURSOR_API_KEY}", "Content-Type": "application/json" } data = { "model": "claude-3.5-sonnet", # O el nombre correcto del modelo "messages": [{"role": "user", "content": prompt}] } response = requests.post(CURSOR_API_ENDPOINT, headers=headers, json=data) response.raise_for_status() # Lanza HTTPError para respuestas incorrectas (4xx o 5xx) response_json = response.json() ai_response = response_json["choices"][0]["message"]["content"] # Ajusta según el formato de respuesta de Cursor return ai_response except requests.exceptions.RequestException as e: print(f"Error al comunicarse con la API de Cursor: {e}") return "Error: No se pudo recuperar la información meteorológica." except (KeyError, IndexError) as e: print(f"Error al analizar la respuesta de la API de Cursor: {e}") return "Error: No se pudo entender la información meteorológica." # --- Manejo de Comandos --- def handle_chat_message(sock, message): """Maneja los mensajes de chat del cliente.""" if message.startswith("/weather"): try: _, location = message.split(" ", 1) # Divide en comando y ubicación weather_info = get_weather_from_ai(location) send_chat_message(sock, f"Clima en {location}: {weather_info}") except ValueError: send_chat_message(sock, "Uso: /weather <ubicación>") else: send_chat_message(sock, f"Dijiste: {message}") def process_client(sock, address): """Maneja la comunicación con un solo cliente.""" try: handle_handshake(sock) username = handle_login(sock) # Bucle principal del juego (simplificado) while True: packet_length = read_varint(sock) if packet_length is None: break # Conexión cerrada packet_id = struct.unpack("b", sock.recv(1))[0] if packet_id == 0x03: # Mensaje de chat message_length = read_varint(sock) message = sock.recv(message_length).decode('utf-8') handle_chat_message(sock, message) else: # Ignora otros paquetes para este ejemplo sock.recv(packet_length - 1) # Consume el resto del paquete except Exception as e: print(f"Error al manejar el cliente: {e}") finally: print(f"Cerrando conexión con {address}") sock.close() # --- Configuración del Servidor --- def main(): """Función principal del servidor.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Permite la reutilización de la dirección server_socket.bind((HOST, PORT)) server_socket.listen(5) # Escucha hasta 5 conexiones print(f"Servidor escuchando en {HOST}:{PORT}") try: while True: client_socket, client_address = server_socket.accept() print(f"Conexión aceptada de {client_address}") client_thread = threading.Thread(target=process_client, args=(client_socket, client_address)) client_thread.start() except KeyboardInterrupt: print("Apagando el servidor...") finally: server_socket.close() if __name__ == "__main__": main() ``` **Explicación y Puntos Clave:** * **Protocolo de Minecraft:** El código implementa un subconjunto muy básico del protocolo de Minecraft. Necesitarás estudiar la documentación del protocolo para una funcionalidad completa. Las funciones `read_varint`, `write_varint` y `send_packet` son cruciales para manejar los enteros de longitud variable utilizados en el protocolo. * **Handshake, Status, Login:** Las funciones `handle_handshake`, `handle_status` y `handle_login` manejan las fases iniciales de la conexión. El servidor envía una respuesta de estado ficticia y un paquete de inicio de sesión exitoso. * **Mensajes de Chat:** La función `handle_chat_message` demuestra cómo recibir y procesar mensajes de chat del cliente. Incluye un comando `/weather`. * **Integración con la IA (`get_weather_from_ai`):** * Este es el núcleo de la integración con la IA. Construye un prompt para Claude-3.7-sonnet, lo envía a la API de Cursor y analiza la respuesta. * **Importante:** Necesitarás reemplazar `"TU_ENDPOINT_DE_LA_API_DE_CURSOR"` y `"TU_CLAVE_DE_LA_API_DE_CURSOR"` con tus credenciales reales de la API de Cursor. * El código utiliza la biblioteca `requests` para realizar peticiones HTTP a la API de Cursor. Asegúrate de tenerla instalada (`pip install requests`). * El código asume una estructura JSON específica para la respuesta de la API de Cursor. Necesitarás ajustar la lógica de análisis (`response_json["choices"][0]["message"]["content"]`) según el formato de respuesta real. * Se incluye el manejo de errores para capturar posibles problemas con la solicitud de la API o el análisis de la respuesta. * **Threading:** El servidor utiliza threads para manejar múltiples conexiones de clientes concurrentemente. * **Manejo de Errores:** Se incluye un manejo de errores básico, pero necesitarás añadir un manejo de errores más robusto para un servidor listo para producción. * **Simplificaciones:** * Este es un ejemplo muy simplificado. No implementa muchas características de un servidor de Minecraft real. * No maneja el movimiento del jugador, la generación del mundo u otra lógica del juego. * La implementación del protocolo de Minecraft está incompleta. * **Seguridad:** Este código no es seguro. Es vulnerable a varios ataques. Necesitarás implementar medidas de seguridad adecuadas para un servidor de producción. **Cómo Usar con Cursor:** 1. **Configura Cursor:** Asegúrate de tener una cuenta de Cursor y tener acceso a la API de Cursor. 2. **Instala `requests`:** `pip install requests` 3. **Reemplaza los Marcadores de Posición:** Reemplaza `"TU_ENDPOINT_DE_LA_API_DE_CURSOR"` y `"TU_CLAVE_DE_LA_API_DE_CURSOR"` con tus credenciales reales de la API de Cursor. 4. **Ejecuta el Servidor:** Ejecuta el script de Python. 5. **Conéctate con Minecraft:** Inicia tu cliente de Minecraft y conéctate a `localhost:25565`. 6. **Usa el comando `/weather`:** En el chat de Minecraft, escribe `/weather <ubicación>` (por ejemplo, `/weather Londres`). El servidor debería enviar una solicitud a Cursor, obtener la información meteorológica de Claude-3.7-sonnet y mostrarla en el chat. **Desarrollo Adicional:** * **Protocolo de Minecraft Completo:** Implementa el protocolo de Minecraft completo para un servidor más funcional. * **Generación del Mundo:** Implementa la generación del mundo para crear un mundo jugable. * **Movimiento del Jugador:** Maneja el movimiento del jugador y las actualizaciones de posición. * **Lógica del Juego:** Implementa la lógica del juego, como el manejo de elementos, las interacciones de entidades y más. * **Integración de la Base de Datos:** Utiliza una base de datos para almacenar datos del jugador, datos del mundo y otra información persistente. * **Seguridad:** Implementa medidas de seguridad para proteger el servidor de ataques. * **Configuración:** Utiliza un archivo de configuración para almacenar la configuración del servidor. * **Registro:** Implementa el registro para rastrear la actividad del servidor y los errores. * **Más Interacciones con la IA:** Explora otras formas de integrar la IA en el servidor, como: * Generar misiones. * Crear eventos dinámicos. * Proporcionar consejos personalizados a los jugadores. * Generar elementos personalizados. **Consideraciones Importantes:** * **Uso de la API de Cursor:** Ten en cuenta los límites de uso de la API de Cursor y los precios. El uso excesivo de la API puede generar costos. * **Limitaciones del Modelo de IA:** Claude-3.7-sonnet (o cualquier modelo de IA) tiene limitaciones. Es posible que no siempre proporcione información precisa o relevante. Necesitarás manejar estas limitaciones con elegancia. * **Ingeniería de Prompts:** La calidad de las respuestas de la IA depende en gran medida de los prompts que proporciones. Experimenta con diferentes prompts para obtener los mejores resultados. Esta plantilla proporciona un punto de partida para construir un servidor de Minecraft impulsado por IA. Recuerda que requiere un desarrollo adicional significativo para convertirse en un servidor completamente funcional y robusto. ¡Buena suerte!

Model Context Protocol (MCP) Types

Servidor de Protocolo de Contexto de Modelo (MCP) para Rust

dap-mcp

Una implementación del Protocolo de Contexto del Modelo (MCP) que permite la interacción con adaptadores de depuración, permitiendo que los modelos de lenguaje controlen depuradores, establezcan puntos de interrupción, evalúen expresiones y naveguen por el código fuente durante las sesiones de depuración.

repo-template

A Python server implementation for Feishu (Lark) bot that follows the Model Context Protocol (MCP). This server provides a standardized interface for handling automated messaging and context-aware interactions within enterprise Feishu environments.

MCP Analysis Templates

Servidor MCP para gestionar y servir plantillas de indicaciones de análisis.

Firecrawl MCP Server

Espejo de

Supabase MCP Server

A Model Context Protocol server that enables Claude and other LLMs to perform database operations and invoke Edge Functions within Supabase through natural language.

Clever Cloud Documentation MCP server

Mirror of

Salesforce MCP Server

Mirror of

Agent Construct

Una implementación de servidor MCP que estandariza la forma en que las aplicaciones de IA acceden a herramientas y contexto, proporcionando un centro centralizado que gestiona el descubrimiento, la ejecución y la gestión del contexto de las herramientas con un sistema de configuración simplificado.

MCP Rust CLI server template

A hello-world server for the Model Context Protocol