Discover Awesome MCP Servers

Data BI MCP Server

Un servidor MCP (Protocolo de Contexto de Modelo) para la transformación de datos y gráficos de BI permitirá a los asistentes de IA conectarse a sus fuentes de datos, transformar datos y generar visualizaciones de alta calidad a través de solicitudes en lenguaje natural.

Bishop MCP (Master Control Program)

Aquí tienes un script avanzado para servidor MCP que he desarrollado y me gustaría compartir.

Rootly MCP Server

Mirror of

WIP: MCP Server Superset

Un servidor de Protocolo de Contexto de Modelo que permite a los modelos de lenguaje grandes interactuar con bases de datos Apache Superset a través de la API REST, admitiendo consultas de bases de datos, búsquedas de tablas, recuperación de información de campos y ejecución de SQL.

Microsoft SQL Server MCP Server

Espejo de

Google Analytics MCP Server

Espejo de

postgres-mcp MCP server

Postgres Pro es un servidor de Protocolo de Contexto de Modelo (MCP) de código abierto creado para brindarte soporte a ti y a tus agentes de IA durante todo el proceso de desarrollo, desde la codificación inicial, pasando por las pruebas y la implementación, hasta el ajuste y el mantenimiento de la producción.

What is Model Context Protocol (MCP)?

Un servidor de Protocolo de Contexto de Modelo (MCP) ligero que permite a tu LLM validar direcciones de correo electrónico. Esta herramienta verifica el formato del correo electrónico, la validez del dominio y la capacidad de entrega utilizando la API de Validación de Correo Electrónico de AbstractAPI. Perfecto para integrar la validación de correo electrónico en aplicaciones de IA como Claude Desktop.

Dify as MCP Server

Expone las aplicaciones de Dify (tanto Chatflow como Workflow) como servidores MCP (Protocolo de Contexto de Modelo), permitiendo que Claude y otros clientes MCP interactúen directamente con las aplicaciones de Dify a través de un protocolo estandarizado.

imagegen-go MCP 服务器

MCP server which will trigger OpenAI to generate image

Weather MCP Server

Un servidor de Protocolo de Contexto de Modelo que proporciona información meteorológica.

Cortellis MCP Server

An MCP server enabling AI assistants to search and analyze pharmaceutical data through Cortellis. Features comprehensive drug search, ontology exploration, and real-time clinical trial data access.

Workers MCP Server

Talk to a Cloudflare Worker from Claude Desktop!

Waldzell MCP Servers

Monorepositorio de servidores MCP de Waldzell AI. ¡Se usa en Claude Desktop, Cline, Roo Code y más!

Goose FM

Okay, here's a breakdown of an MVP (Minimum Viable Product) for an MCP (Minecraft Protocol) server that allows AI assistants to "tune into" FM radio stations within Minecraft. This focuses on core functionality and avoids unnecessary complexity for the initial release. **Core Concept:** The AI assistant (e.g., a Python script using a library like `minecraft-protocol`) connects to the Minecraft server. It sends commands to interact with a virtual "radio" block. The server then streams audio from a real-world FM radio station to the AI assistant. **MVP Features:** 1. **Basic MCP Server:** * **Implementation:** Use a lightweight MCP server library (e.g., `node-minecraft-protocol` for Node.js, or `mcproto` for Python). Focus on handling basic connection and command parsing. * **Functionality:** * Accept connections from a single AI assistant client. * Authenticate the client (simple password or token-based authentication). * Handle basic chat messages (for debugging and status). 2. **Virtual Radio Block:** * **Representation:** A single, designated block in the Minecraft world (e.g., a specific type of block at a fixed coordinate). * **Interaction:** * The AI assistant sends a command to "interact" with the radio block (e.g., `/radio on`, `/radio off`, `/radio station <frequency>`). The server parses these commands. * The server sends feedback to the AI assistant (e.g., "Radio turned on", "Tuning to 98.7 FM", "Radio turned off"). This can be done via chat messages or custom packets. 3. **FM Radio Streaming:** * **Radio Source:** Use a reliable online FM radio streaming service or a local FM receiver connected to the server. Consider using a library like `vlc` or `ffmpeg` to capture the audio stream. * **Audio Encoding:** Encode the audio stream into a format suitable for transmission over the network (e.g., MP3, Opus). Keep the bitrate low to minimize bandwidth usage. * **Streaming to AI Assistant:** * Establish a separate TCP connection (or use WebSockets) between the server and the AI assistant for audio streaming. * Send audio data in small chunks to the AI assistant. * Implement basic error handling (e.g., reconnect if the stream is interrupted). 4. **AI Assistant Client (Example in Python):** ```python import minecraft_protocol import socket import threading import time SERVER_ADDRESS = ("localhost", 25565) # Replace with your server's address USERNAME = "AI_Assistant" PASSWORD = "password" # Replace with your password RADIO_STREAM_PORT = 12345 # Port for audio stream def receive_audio(sock): try: while True: data = sock.recv(1024) # Adjust buffer size as needed if not data: break # Process audio data (e.g., play it using a library like PyAudio) print(f"Received audio data: {len(data)} bytes") # Replace with actual audio playback except Exception as e: print(f"Error receiving audio: {e}") finally: sock.close() def main(): try: client = minecraft_protocol.Client(SERVER_ADDRESS[0], SERVER_ADDRESS[1], USERNAME) client.login(USERNAME, PASSWORD) print("Connected to Minecraft server.") # Connect to audio stream audio_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) audio_socket.connect((SERVER_ADDRESS[0], RADIO_STREAM_PORT)) print("Connected to audio stream.") audio_thread = threading.Thread(target=receive_audio, args=(audio_socket,)) audio_thread.daemon = True audio_thread.start() # Send commands to the server client.chat("/radio on") time.sleep(2) client.chat("/radio station 98.7") time.sleep(10) # Listen for a while client.chat("/radio off") client.close() print("Disconnected from Minecraft server.") except Exception as e: print(f"Error: {e}") if __name__ == "__main__": main() ``` **Technical Considerations:** * **Audio Latency:** Streaming audio over a network will introduce latency. Minimize this by using a low bitrate and efficient encoding. * **Bandwidth:** Consider the bandwidth requirements of streaming audio, especially if multiple AI assistants are connected. * **Error Handling:** Implement robust error handling to deal with network interruptions, invalid commands, and other potential issues. * **Security:** For the MVP, simple authentication is sufficient. For a production system, use more secure authentication methods. * **Scalability:** The MVP is designed for a single AI assistant. Consider scalability issues if you plan to support multiple clients. **Development Steps:** 1. **Set up the MCP server:** Choose a library and implement the basic server functionality (connection handling, authentication, chat). 2. **Implement the virtual radio block:** Define the block and handle the `/radio` commands. 3. **Implement the FM radio streaming:** Capture audio from a source, encode it, and stream it to the AI assistant. 4. **Develop the AI assistant client:** Connect to the server, send commands, and receive and play the audio stream. 5. **Test and debug:** Thoroughly test the system to identify and fix any issues. **Why this is an MVP:** * **Focus on core functionality:** It only implements the essential features needed to demonstrate the concept. * **Limited scope:** It supports a single AI assistant and a single radio block. * **Simplified implementation:** It uses simple authentication and error handling. * **Iterative development:** This MVP can be used as a foundation for adding more features and improving the system over time. **Possible Future Enhancements:** * **Multiple radio stations:** Allow the AI assistant to select from a list of available stations. * **Volume control:** Implement volume control for the radio. * **User interface:** Create a more user-friendly interface for the AI assistant. * **Multiple AI assistants:** Support multiple AI assistants connecting to the server. * **Integration with other Minecraft features:** Integrate the radio with other Minecraft features, such as redstone circuits. * **Spatial Audio:** Make the audio louder the closer you are to the radio block. This MVP provides a solid starting point for building a more complex and feature-rich system. Remember to prioritize simplicity and focus on delivering a working product as quickly as possible. Good luck!

MCP Server

(STDIO) Model Context Protocol (MCP) servers designed for local execution

mcp-server-proxy

Converts MCP protocol's SSE transport layer to a standard HTTP request/response.

Podman MCP Server

Model Context Protocol (MCP) server for container runtimes (Podman and Docker)

Coinmarket MCP server

Mirror of

Claude Desktop Commander MCP

Permite a Claude ejecutar comandos de terminal en tu computadora y realizar operaciones en el sistema de archivos, incluyendo la edición quirúrgica de código con reemplazos basados en diff.

Quarkus Model Context Protocol (MCP) Server

Mirror of

binance-p2p-mcp-server

Here are a few options, depending on the specific nuance you want to convey: **Option 1 (Most Direct):** * **Binance (con enfoque en P2P primero) Protocolo de Servidor de Contexto de Modelo** **Option 2 (Slightly more descriptive):** * **Binance (priorizando P2P) Protocolo de Servidor de Contexto de Modelo** **Option 3 (If "Model Context Protocol Server" is a well-known term, you might leave it in English):** * **Binance (con enfoque en P2P primero) Model Context Protocol Server** (This assumes the target audience understands the English term.) **Explanation of Choices:** * **Binance:** This remains the same as it's a proper noun. * **focus in P2P firstly:** * `con enfoque en P2P primero`: "with a focus on P2P first" - This is a very literal and common translation. * `priorizando P2P`: "prioritizing P2P" - This is a bit more concise and emphasizes the priority. * **Model Context Protocol Server:** This is the trickiest part. Without more context, it's hard to know if this is a standard term that should be left in English, or if it needs translation. If it needs translation, it would be something like: * `Protocolo de Servidor de Contexto de Modelo` - This is a direct translation. Whether it makes sense to a Spanish-speaking audience depends on their familiarity with the concept. **Recommendation:** I would lean towards **Option 1: Binance (con enfoque en P2P primero) Protocolo de Servidor de Contexto de Modelo** unless you know for sure that "Model Context Protocol Server" is a term commonly used and understood in English by your target audience. If you know the audience is familiar with the English term, then **Option 3** is best. To give you the *best* translation, I need more context. What is this *exactly*? Who is the target audience? Knowing this will help me choose the most appropriate and understandable translation.

MCP Dockmaster

MCP Dockmaster allows you to easily install and manage MCP servers. Available for Mac, Windows and Linux as a Desktop App, CLI and a library.

Documentation Retrieval MCP Server (DOCRET)

Un servidor MCP que permite a los asistentes de IA acceder a documentación actualizada de bibliotecas de Python como LangChain, LlamaIndex y OpenAI mediante la obtención dinámica desde fuentes oficiales.

ModelContextProtocol (MCP) Java SDK v0.8.0 Specification

Okay, here's a breakdown of instructions for an AI on how to create a Java-based Minecraft Protocol (MCP) server and client. This is a complex task, so the instructions are broken down into manageable steps. The AI should be able to follow these instructions, assuming it has access to Java development tools and Minecraft protocol documentation. **I. Understanding the Goal and Prerequisites** * **Goal:** Create a basic Java application that can act as both a Minecraft server (handling client connections and basic world data) and a Minecraft client (connecting to a server and sending/receiving data). This will *not* be a full-fledged Minecraft server or client, but a simplified version for learning and experimentation. * **Prerequisites:** * **Java Development Kit (JDK):** The AI needs to have access to a JDK (version 8 or higher is recommended). * **Integrated Development Environment (IDE):** An IDE like IntelliJ IDEA, Eclipse, or NetBeans is highly recommended for code editing, debugging, and project management. * **Minecraft Protocol Documentation:** The AI *must* have access to up-to-date Minecraft protocol documentation. This is crucial for understanding the packet structure and handshake process. A good starting point is the Wiki.vg Minecraft Protocol page (search for "Wiki.vg Minecraft Protocol"). The AI should be able to access and parse this documentation. * **Networking Knowledge:** The AI should have a basic understanding of TCP/IP networking, sockets, and streams. * **Data Serialization/Deserialization:** The AI needs to understand how to serialize and deserialize data into byte streams for network transmission and back into Java objects. * **Compression/Encryption (Optional):** For a more realistic implementation, the AI should understand how to implement compression (zlib) and encryption (AES) as used in the Minecraft protocol. **II. Project Setup** 1. **Create a New Java Project:** * Create a new Java project in the chosen IDE. * Name the project something like "SimpleMinecraft." * Set up the project structure with appropriate packages (e.g., `server`, `client`, `protocol`, `util`). 2. **Dependencies (if needed):** * If using external libraries for networking or data handling, add them as dependencies to the project. For example, libraries for handling UUIDs or JSON might be useful. Maven or Gradle can be used for dependency management. **III. Server Implementation** 1. **Server Socket Setup:** * Create a `ServerSocket` to listen for incoming client connections on a specific port (e.g., 25565, the default Minecraft port). * Use a `while` loop to continuously accept new client connections. * For each new connection, create a new `Thread` to handle the client's communication. 2. **Client Connection Handling (within the Thread):** * Get the `Socket` from the accepted connection. * Create `InputStream` and `OutputStream` objects for reading data from and writing data to the client. 3. **Handshake:** * **Read the Handshake Packet (ID 0x00):** Parse the incoming data stream to extract the protocol version, server address, and next state (1 for status, 2 for login). Refer to the Minecraft protocol documentation for the exact packet structure. * **Handle Status Request (State 1):** * **Respond with Status Response Packet (ID 0x00):** Create a JSON string containing server information (e.g., MOTD, player count, protocol version). Serialize this JSON string into a packet and send it to the client. * **Handle Ping Request Packet (ID 0x01):** Read the ping payload from the client. * **Respond with Ping Response Packet (ID 0x01):** Send the same ping payload back to the client. * Close the connection. * **Handle Login Request (State 2):** * **Read Login Start Packet (ID 0x00):** Parse the player's username from the packet. * **Authentication (Simplified):** For this simplified server, skip full authentication. Just assign a UUID to the player. * **Send Login Success Packet (ID 0x02):** Send a packet containing the player's UUID and username. * **Send Join Game Packet (ID 0x26 (1.16.5) - Packet ID changes with version)):** Send a packet containing information about the game (e.g., entity ID, gamemode, dimension). This packet's structure is version-dependent. * **Send other necessary packets:** Depending on the desired functionality, send packets like `SpawnPosition`, `PlayerAbilities`, `HeldItemChange`, `ChunkData`, `EntityMetadata`, etc. These packets are crucial for setting up the player's initial state in the world. 4. **Game Loop (Basic):** * After the login sequence, enter a basic game loop. * **Receive Packets:** Continuously read packets from the client. * **Process Packets:** Handle incoming packets (e.g., chat messages, player movement). For a simple server, you might only handle chat messages and ignore movement. * **Send Updates:** Send updates to the client (e.g., chat messages from other players, changes in the world). **IV. Client Implementation** 1. **Socket Connection:** * Create a `Socket` to connect to the server's IP address and port. * Create `InputStream` and `OutputStream` objects for reading data from and writing data to the server. 2. **Handshake:** * **Create and Send Handshake Packet (ID 0x00):** Construct the handshake packet with the correct protocol version, server address, and next state (2 for login). * **Create and Send Login Start Packet (ID 0x00):** Construct the login start packet with the desired username. 3. **Login Handling:** * **Receive Login Success Packet (ID 0x02):** Parse the player's UUID and username from the packet. * **Receive Join Game Packet (ID 0x26 (1.16.5)):** Parse the game information from the packet. 4. **Game Loop (Basic):** * After the login sequence, enter a basic game loop. * **Receive Packets:** Continuously read packets from the server. * **Process Packets:** Handle incoming packets (e.g., chat messages, world updates). * **Send Packets:** Send packets to the server (e.g., chat messages, player movement). **V. Protocol Handling (Crucial)** 1. **Packet Structure:** * The AI *must* understand the structure of Minecraft packets. Each packet consists of: * **Length:** A variable-length integer (VarInt) indicating the length of the packet data that follows. * **ID:** A VarInt indicating the packet ID. * **Data:** The packet-specific data, formatted according to the packet ID. 2. **VarInt Encoding/Decoding:** * Implement methods to encode and decode VarInts. VarInts are used extensively in the Minecraft protocol. They are variable-length integers that use a variable number of bytes to represent the integer value. 3. **Data Types:** * Understand and implement methods for reading and writing the following data types: * `byte` * `short` * `int` * `long` * `float` * `double` * `boolean` * `String` (UTF-8 encoded) * `UUID` * `VarInt` * Arrays of the above types 4. **Packet Classes:** * Create Java classes to represent each packet type. Each class should have fields corresponding to the packet's data fields. * Implement methods in each packet class to serialize the data into a byte stream and deserialize the data from a byte stream. **VI. Error Handling and Logging** * Implement proper error handling to catch exceptions (e.g., `IOException`, `SocketException`). * Use a logging framework (e.g., `java.util.logging`, Log4j) to log important events and errors. **VII. Version Compatibility** * The Minecraft protocol changes frequently. The AI *must* be aware of the protocol version it is targeting. * Consider using a configuration file or command-line argument to specify the protocol version. * Implement version-specific packet handling logic. **VIII. Code Structure and Design** * Use a modular design to separate concerns. * Create classes for: * `MinecraftServer` * `MinecraftClient` * `ClientConnection` (for handling individual client connections on the server) * `Packet` (abstract class for all packets) * `PacketHandshakingInSetProtocol` * `PacketLoginInStart` * `PacketLoginOutSuccess` * `PacketStatusOutServerInfo` * `PacketStatusInPing` * `PacketStatusOutPong` * `VarInt` (utility class for VarInt encoding/decoding) * `DataUtil` (utility class for reading/writing data types) **IX. Testing** * Thoroughly test the server and client to ensure they can connect, authenticate, and exchange data correctly. * Use a real Minecraft client to connect to the server and verify that it works as expected. **Example Code Snippets (Illustrative - Not Complete)** ```java // Example: Reading a VarInt public static int readVarInt(InputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = (byte) in.read(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } // Example: Writing a VarInt public static void writeVarInt(OutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.write(value); return; } out.write((value & 0x7F) | 0x80); value >>>= 7; } } // Example: Handshake Packet (Simplified) public class PacketHandshakingInSetProtocol extends Packet { private int protocolVersion; private String serverAddress; private int serverPort; private int nextState; public PacketHandshakingInSetProtocol(InputStream in) throws IOException { // Read data from the input stream based on the protocol // version and packet structure. Use readVarInt and other // data reading methods. protocolVersion = DataUtil.readVarInt(in); serverAddress = DataUtil.readString(in); serverPort = in.read(); //Simplified, should be short nextState = DataUtil.readVarInt(in); } // Getters for the fields } ``` **Important Considerations for the AI:** * **Protocol Version:** The AI *must* be able to handle different Minecraft protocol versions. The packet IDs and data structures change between versions. * **Security:** This is a simplified implementation. A real Minecraft server needs to handle authentication and encryption properly to prevent security vulnerabilities. * **Performance:** This implementation is not optimized for performance. A real Minecraft server needs to handle a large number of concurrent connections efficiently. * **World Generation:** This implementation does not include world generation. A real Minecraft server needs to generate and manage the game world. * **Game Logic:** This implementation only includes basic game logic. A real Minecraft server needs to implement all of the game's rules and mechanics. This detailed breakdown should provide the AI with a solid foundation for creating a Java-based Minecraft protocol server and client. Remember that this is a complex project, and the AI will need to consult the Minecraft protocol documentation frequently. Good luck!

Recall MCP Server

Un servidor MCP sencillo que expone la funcionalidad básica de Recall, incluyendo la lista de buckets, la obtención de saldos de cuentas, la creación de objetos y más.

E2B MCP Server

Mirror of