Discover Awesome MCP Servers

Zephyr MCP Server

A lightweight server that simplifies building and flashing Zephyr RTOS projects through a REST API, allowing remote control of the microcontroller programming workflow.

KiCad MCP Server

Enables natural language search and exploration of KiCad component symbol libraries with fast full-text search across 20,000+ components including metadata like datasheets, footprints, and descriptions.

OpenRouter Search MCP Server

Servidor MCP para la funcionalidad de búsqueda de OpenRouter

mcp-server-for-local

¡Hola a todos! Soy un servicio MCP rico en funciones, diseñado para romper las barreras entre dispositivos y servicios, brindando una experiencia conveniente a los usuarios. La herramienta del clima se vincula con la plataforma meteorológica para enviar rápidamente el clima global en tiempo real a los usuarios, ayudándolos a planificar sus viajes. La herramienta de control del navegador simula la operación manual, buscando y navegando automáticamente por las páginas web, ahorrando mucho tiempo. La herramienta de la cámara llama a la cámara local para tomar fotos y grabar videos, implementando el reconocimiento facial para garantizar la seguridad del hogar. Para lograr la colaboración de las herramientas, he construido un marco estable, y los desarrolladores pueden expandirse basándose en los servicios existentes.

Knowledge Graph Memory Server

Provides persistent memory for Claude by implementing a local knowledge graph to store and retrieve entities, relations, and observations. This enables long-term information retention and personalization across different chat sessions.

AiryLark MCP Translation Server

Un servidor ModelContextProtocol que ofrece servicios de traducción de alta calidad con un flujo de trabajo de traducción de tres etapas (análisis, traducción segmentada, revisión de texto completo) que admite múltiples idiomas y se integra con modelos compatibles con Claude y OpenAI.

Remote MCP Server with WorkOS AuthKit

An example MCP server that allows remote clients to connect and authenticate using WorkOS AuthKit, providing organization-centric authentication with permission-based access control for tools.

Nara Market FastMCP Server

Provides access to South Korean government procurement (G2B) and Nara Market shopping mall data, enabling users to search bid announcements, procurement statistics, product catalogs, and contract information through 15 specialized tools.

MCP client-server

Okay, I can help you understand the concept and provide a basic outline for creating an MCP (Minecraft Protocol) client and server. However, building a fully functional MCP client and server is a complex task that requires significant programming knowledge and time. I'll give you a simplified overview and point you in the right direction. **Understanding the Minecraft Protocol (MCP)** The Minecraft Protocol is the communication protocol used between Minecraft clients and servers. It's a binary protocol, meaning data is sent as raw bytes, not human-readable text. It's constantly evolving with each Minecraft version. Key aspects include: * **Handshaking:** The initial connection process where the client and server agree on the protocol version. * **Login:** Authentication of the player. * **Data Packets:** Packets are used to send information about the world, entities, player actions, chat messages, and more. Each packet has a specific ID and a defined structure. * **Compression:** The protocol supports compression to reduce bandwidth usage. * **Encryption:** The protocol uses encryption to protect sensitive data like passwords. **High-Level Outline** Here's a general outline for creating a basic MCP client and server: **1. Choose a Programming Language:** * **Java:** The language Minecraft is written in. It's a natural choice and has libraries that can help. * **Python:** Easier to learn and prototype with, but might be less performant for a full-fledged server. * **C++:** Offers the best performance but is more complex. * **C#:** A good option, especially if you're familiar with .NET. **2. Set Up Networking:** * **Sockets:** Use sockets to establish a TCP connection between the client and server. This is the foundation of network communication. **3. Implement the Handshake:** * **Client:** * Send a handshake packet to the server. This packet includes the protocol version, server address, and next state (login or status). * **Server:** * Receive the handshake packet. * Validate the protocol version. * Set the connection state based on the "next state" value. **4. Implement Login (Simplified):** * **Client:** * Send a login start packet with the player's username. * **Server:** * Receive the login start packet. * (For a very basic server, you might skip authentication and just accept the username.) * Send a login success packet back to the client. * **Client:** * Receive the login success packet. **5. Implement Basic Data Packet Handling:** * **Client & Server:** * Define structures for the packets you want to support (e.g., chat messages, player position updates). * Implement functions to serialize (encode) data into packets and deserialize (decode) packets into data. * Use a packet ID to identify the type of packet being sent/received. * Implement a main loop that continuously reads data from the socket, identifies the packet, and processes it. **6. Implement Compression (Optional):** * Use a compression algorithm like zlib to compress packets before sending them. **7. Implement Encryption (Optional):** * Use encryption (e.g., AES) to encrypt packets after the handshake. **Example (Conceptual - Python):** ```python import socket import struct # For packing/unpacking binary data # --- Server --- def handle_client(client_socket): # Receive handshake handshake_data = client_socket.recv(256) # Adjust buffer size as needed # ... (Parse handshake data to get protocol version, etc.) # Send login success (simplified) login_success_packet = struct.pack(">bi", 0x02, 12345) # Example packet ID and data client_socket.sendall(login_success_packet) # Main loop (receive and process packets) while True: try: packet_header = client_socket.recv(2) # Example: 2 bytes for packet ID if not packet_header: break # Connection closed packet_id = struct.unpack(">h", packet_header)[0] # Unpack short (2 bytes) if packet_id == 0x01: # Example: Chat message packet # ... (Receive chat message data) # ... (Process chat message) pass else: print(f"Unknown packet ID: {packet_id}") except ConnectionResetError: print("Client disconnected") break # --- Client --- def connect_to_server(server_address, server_port): client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) client_socket.connect((server_address, server_port)) # Send handshake handshake_packet = struct.pack(">bi", 0x00, 762) # Example packet ID and protocol version client_socket.sendall(handshake_packet) # Receive login success login_success_data = client_socket.recv(256) # ... (Parse login success data) # Main loop (send and receive packets) while True: # ... (Create a chat message packet) chat_message_packet = struct.pack(">hi", 0x01, 67890) # Example packet ID and data client_socket.sendall(chat_message_packet) # ... (Receive packets from the server) server_data = client_socket.recv(256) # ... (Process server data) ``` **Important Considerations:** * **Protocol Version:** The Minecraft protocol changes with each version. You *must* use the correct protocol version for the Minecraft client you want to connect to. You can find protocol information on the Minecraft Wiki and in community-maintained documentation. * **Data Types:** The protocol uses specific data types (e.g., VarInt, VarLong, strings with prefixes). You need to handle these correctly. * **Error Handling:** Implement robust error handling to deal with network issues, invalid packets, and other unexpected situations. * **Security:** Be very careful about security, especially if you're handling authentication. Never store passwords in plain text. * **Threading/Asynchronous Programming:** For a server, you'll need to use threading or asynchronous programming to handle multiple clients concurrently. **Where to Find More Information:** * **Minecraft Protocol Wiki:** The official Minecraft Wiki is a good starting point, but it may not always be up-to-date. Search for "Minecraft Protocol" on the wiki. * **Wiki.vg:** This is a very valuable resource for the Minecraft protocol. It has detailed information about packets, data types, and the handshake process. [https://wiki.vg/Protocol](https://wiki.vg/Protocol) * **Community Projects:** Look at open-source Minecraft client and server implementations (e.g., in Java, Python, or C++) for inspiration and examples. Be aware that these projects can be complex. * **Books and Tutorials:** Search online for tutorials and books on Minecraft server development. **In summary, building an MCP client and server is a significant undertaking. Start with the basics (sockets, handshake, login) and gradually add more features. Use the resources I've provided to understand the protocol and learn from existing projects.**

Edgee MCP Server

MCP Server for the Edgee API, enabling organization management, project operations, component management, and user administration through the Model Context Protocol.

MCP Domain Availability Server

Enables checking domain availability and pricing using the GoDaddy OTE API, supporting multiple TLD suffixes and both fast and full check modes.

ThinMCP

A local MCP gateway that compresses multiple upstream servers into two tools, search and execute, to minimize model context usage. It provides a compact, code-driven interface for discovering and calling tools across various upstream sources on demand.

Brightspace MCP Server

MCP server for Brightspace (D2L): check grades, due dates, announcements, rosters & more using Claude, ChatGPT, Cursor, or any MCP client. Built with TypeScript and the D2L REST API.

OmniSocKit MCP Server

Provides AI models with precise development knowledge and implementation rules for social marketing platforms like WeCom. It enables AI tools to generate accurate, production-ready code by injecting real-world API constraints and best practices without calling external APIs.

WHOOP MCP Server

Enables access to WHOOP fitness and health data through all WHOOP v2 API endpoints. Supports OAuth 2.0 authentication and provides comprehensive access to user profiles, physiological cycles, recovery metrics, sleep analysis, and workout data.

Featurebase MCP Server

Enables interaction with Featurebase API to manage feature requests, feedback posts, comments, and upvotes. Supports creating, updating, and organizing customer feedback through natural language commands.

MCP Server Collection

The most accurate translation of "mcp服务聚合" depends on the context. Here are a few options: * **If referring to a general aggregation of MCP services:** * **Agregación de servicios MCP** * **If referring to a platform or system that aggregates MCP services:** * **Plataforma de agregación de servicios MCP** * **Sistema de agregación de servicios MCP** * **If referring to the process of aggregating MCP services:** * **Agregación de servicios MCP** (same as the first option, but emphasizes the action) Without more context, "Agregación de servicios MCP" is the safest and most general translation.

Formula1 MCP Server

Proporciona datos de carreras de Fórmula 1 en tiempo real e históricos a través del Protocolo de Contexto del Modelo, ofreciendo acceso a datos de cronometraje, estadísticas de pilotos, resultados de carreras, telemetría y más.

Path of Exile 2 Build Optimizer MCP

Enables AI-powered Path of Exile 2 character optimization through natural language queries, providing intelligent build recommendations, gear upgrades, and passive tree optimization using the official PoE API and comprehensive game database.

MCP GraphQL Query Generator

Automatically discovers GraphQL APIs through introspection and generates table-formatted queries with pagination, filters, and sorting. Supports multiple authentication types and provides both CLI and REST API interfaces for seamless integration.

Accounting MCP

A personal financial management tool that enables AI assistants to record transactions, check balances, and provide monthly financial summaries via the Model Context Protocol. It allows users to manage their expenses and income through natural language interactions using standardized MCP tools and resources.

Echo MCP Server

Okay, here's a basic outline and code example of a Model Context Protocol (MCP) server implementing an echo service using .NET Core. Since MCP is a somewhat abstract concept, I'll make some assumptions about how you want to use it. This example focuses on the core principles of receiving data, processing it (echoing), and sending it back. **Assumptions and Simplifications:** * **Transport:** I'll use TCP sockets as the underlying transport mechanism. MCP doesn't dictate the transport, but TCP is common and relatively straightforward. * **Message Framing:** I'll assume a simple line-based framing. Each message is terminated by a newline character (`\n`). This makes it easy to read and write messages. You might need to adapt this based on your specific MCP requirements. * **Error Handling:** Basic error handling is included, but a production system would need more robust error handling and logging. * **Model Context:** In this simple echo service, the "model context" is essentially the connection itself. More complex MCP implementations might involve associating data or state with each connection. * **.NET Core Version:** This example uses .NET 6 or later. **Code Example (C#):** ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace MCPEchoServer { class Program { static async Task Main(string[] args) { int port = 12345; // Choose a port IPAddress ipAddress = IPAddress.Any; // Listen on all interfaces TcpListener listener = new TcpListener(ipAddress, port); try { listener.Start(); Console.WriteLine($"MCP Echo Server listening on {ipAddress}:{port}"); while (true) { TcpClient client = await listener.AcceptTcpClientAsync(); Console.WriteLine($"Accepted connection from {client.Client.RemoteEndPoint}"); _ = Task.Run(() => HandleClientAsync(client)); // Handle each client in a separate task } } catch (Exception e) { Console.WriteLine($"Error: {e.Message}"); } finally { listener.Stop(); } } static async Task HandleClientAsync(TcpClient client) { try { NetworkStream stream = client.GetStream(); byte[] buffer = new byte[1024]; // Buffer for reading data StringBuilder messageBuilder = new StringBuilder(); while (true) { int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); if (bytesRead == 0) { // Client disconnected Console.WriteLine($"Client {client.Client.RemoteEndPoint} disconnected."); break; } string receivedData = Encoding.UTF8.GetString(buffer, 0, bytesRead); messageBuilder.Append(receivedData); // Check for newline character (message delimiter) while (messageBuilder.ToString().Contains("\n")) { string message = messageBuilder.ToString().Substring(0, messageBuilder.ToString().IndexOf("\n")); messageBuilder.Remove(0, message.Length + 1); // Remove the message and the newline Console.WriteLine($"Received: {message}"); // Echo the message back to the client string echoMessage = $"{message}\n"; // Add newline back for the response byte[] echoBytes = Encoding.UTF8.GetBytes(echoMessage); await stream.WriteAsync(echoBytes, 0, echoBytes.Length); Console.WriteLine($"Sent: {echoMessage.Trim()}"); //Trim to remove the newline for console output } } } catch (Exception e) { Console.WriteLine($"Error handling client {client.Client.RemoteEndPoint}: {e.Message}"); } finally { client.Close(); } } } } ``` **Explanation:** 1. **`Main` Method:** * Sets up a `TcpListener` to listen for incoming connections on a specified port. * Enters a loop to accept incoming `TcpClient` connections. * For each accepted client, it starts a new `Task` to handle the client connection asynchronously using the `HandleClientAsync` method. This allows the server to handle multiple clients concurrently. 2. **`HandleClientAsync` Method:** * Gets the `NetworkStream` from the `TcpClient`. This stream is used for reading and writing data. * Creates a buffer to read data from the stream. * Enters a loop to continuously read data from the client. * **Reading Data:** `stream.ReadAsync` reads data from the stream into the buffer. * **Client Disconnection:** If `bytesRead` is 0, it means the client has disconnected. * **Message Assembly:** The received data is appended to a `StringBuilder` called `messageBuilder`. This is important because a single `ReadAsync` call might not receive the entire message at once. * **Message Delimiting (Framing):** The code checks if the `messageBuilder` contains a newline character (`\n`). This is how we determine the end of a message. * **Message Extraction:** If a newline is found, the message is extracted from the `messageBuilder`. * **Echoing:** The extracted message is echoed back to the client by writing it to the `NetworkStream`. A newline character is added back to the echoed message. * **Error Handling:** A `try-catch` block handles potential exceptions during the client handling process. * **Closing the Connection:** The `client.Close()` method closes the connection when the client disconnects or an error occurs. **How to Run:** 1. **Save:** Save the code as a `.cs` file (e.g., `MCPEchoServer.cs`). 2. **Create a Project:** Create a new .NET Core console application project. You can do this from the command line: ```bash dotnet new console -o MCPEchoServer cd MCPEchoServer ``` 3. **Replace Contents:** Replace the contents of `Program.cs` with the code above. 4. **Run:** Build and run the application from the command line: ```bash dotnet run ``` **Testing (using `netcat` or a similar tool):** 1. Open a terminal or command prompt. 2. Use `netcat` (or a similar tool like `telnet`) to connect to the server: ```bash nc localhost 12345 ``` 3. Type a message and press Enter. The server should echo the message back to you. For example: ``` Hello, MCP World! Hello, MCP World! ``` 4. Type another message and press Enter. 5. To disconnect, you can usually press `Ctrl+C` or `Ctrl+D`. **Important Considerations and Potential Improvements:** * **Message Framing:** The newline-based framing is simple but might not be suitable for all scenarios. Consider using a more robust framing mechanism, such as: * **Length-Prefix Framing:** Include the length of the message at the beginning of the message. * **Delimited Framing:** Use a special delimiter sequence that is unlikely to appear in the message itself. * **Error Handling:** Implement more comprehensive error handling, including logging errors to a file or database. * **Concurrency:** The current example uses `Task.Run` to handle clients concurrently. For high-performance servers, consider using asynchronous I/O (e.g., `Socket.ReceiveAsync` and `Socket.SendAsync`) directly to avoid blocking threads. The current implementation, while using `ReadAsync` and `WriteAsync`, still blocks a thread per client. True asynchronous I/O would use I/O completion ports and avoid thread blocking. * **Model Context:** Implement a more sophisticated model context management system. This might involve storing data associated with each connection in a dictionary or other data structure. Consider using a dependency injection container to manage the lifecycle of model context objects. * **Security:** If you're transmitting sensitive data, consider using TLS/SSL to encrypt the connection. * **Configuration:** Externalize configuration settings (e.g., port number, IP address) to a configuration file. * **Buffering:** Carefully manage buffer sizes to avoid buffer overflows or other issues. * **Cancellation:** Implement cancellation tokens to allow graceful shutdown of the server. * **MCP Specification:** Refer to the specific MCP specification you are implementing to ensure compliance. The term "Model Context Protocol" is somewhat generic, so understanding the specific requirements is crucial. This example provides a starting point for building an MCP echo server in .NET Core. Remember to adapt it to your specific needs and requirements. If you can provide more details about the specific MCP you're working with, I can provide more tailored guidance.

MLB SportRadar MCP Server

Connects Claude to the SportRadar MLB API to access real-time baseball data including game schedules, live scores, player statistics, team standings, injury reports, and play-by-play information through natural language queries.

cook-tool

A recipe query tool that supports querying recipes and reporting dish names through the command line, suitable for cooking enthusiasts and developers.

MCP Dockerized Server

A minimal, containerized MCP server that exposes a Streamable HTTP transport with API key authentication, allowing secure access to MCP endpoints.

BinDiff MCP Tool

Enables binary comparison capabilities by leveraging IDA Pro and BinDiff to analyze similarities and differences between files. Users can perform automated function analysis to identify changed functions and compare original binaries against patched versions.

MUXI Framework

Un marco de agentes de IA extensible.