Discover Awesome MCP Servers

Things MCP Server

Integrates with Things 3 task management app on macOS via URL schemes, enabling creation, updating, deletion of todos and projects, navigation, search, and JSON batch imports.

Futurama Quote Machine MCP Server

Enables interaction with Futurama quotes through Claude Desktop by connecting to the Futurama Quote Machine API. Supports getting random quotes, searching by character, adding new quotes, editing existing ones, and managing the quote collection through natural language.

go-mcp-server-mds

Implementasi Go dari server Model Context Protocol (MCP) yang menyajikan berkas markdown dengan dukungan frontmatter dari sistem berkas.

Hong Kong Creative Goods Trade MCP Server

Provides access to Hong Kong's recreation, sports, and cultural data through a FastMCP interface, allowing users to retrieve statistics on creative goods trade including domestic exports, re-exports, and imports with optional year filtering.

Sequential Thinking Tool API

A Node.js/TypeScript backend for managing sequential thinking sessions, allowing users to create sessions and post thoughts in a structured sequence with support for real-time updates via Server-Sent Events.

MCP Documentation Server

Enables semantic search and retrieval of MCP (Model Context Protocol) documentation using Redis-backed embeddings, allowing users to query and access documentation content through natural language.

Kubernetes MCP Server

Enables managing Kubernetes clusters through natural language by providing tools to list resources, view logs, port-forward services, scale deployments, and execute kubectl operations via AI assistants.

Trusted GMail MCP Server

Server MCP Tepercaya pertama yang berjalan di Lingkungan Eksekusi Tepercaya AWS Nitro Enclave

DataForSEO MCP Server

Sebuah server berbasis stdio yang memungkinkan interaksi dengan DataForSEO API melalui Model Context Protocol, memungkinkan pengguna untuk mengambil data SEO termasuk hasil pencarian, data kata kunci, tautan balik, analisis on-page, dan lainnya.

MCP Iceberg Catalog

Server MCP untuk berinteraksi dengan katalog Apache Iceberg dari Claude, memungkinkan penemuan data lake dan pencarian metadata melalui prompt LLM.

GitHub MCP Server in Go

Implementasi tidak resmi dari server mcp untuk github di go. Digunakan secara internal di Metoro.

Firelinks MCP Server

Enables interaction with the Firelinks link shortening platform to create and manage short links, track click statistics, manage custom domains, and compare analytics periods through natural language.

Mood Playlist MCP Server

Generates personalized music playlists based on mood analysis using AI sentiment detection and emoji understanding. Integrates with Last.fm API to create playlists with multi-language support and provides streaming links for Spotify, Apple Music, and YouTube.

HPE OneView MCP Server

Enables AI agents to manage HPE OneView infrastructure through the REST API, including server hardware operations, power control, profile management, and network/storage configuration.

MCP Server Collection

Layanan agregasi MCP

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.

Solana MCP Wallet Agent API

Provides complete wallet management functionality for Solana blockchain, enabling users to create wallets, transfer SOL, and work with SPL tokens through a RESTful API.

Echo MCP Server

Here's a basic example of a Model Context Protocol (MCP) server implementing an echo service using .NET Core. This example focuses on the core concepts and assumes a simplified MCP structure for demonstration. A real-world MCP implementation would likely be more complex and tailored to specific needs. **Important Considerations:** * **MCP Specification:** This example assumes a simplified MCP structure. You'll need to adapt it to the specific MCP specification you're working with. Key aspects of the specification include: * **Message Framing:** How messages are delimited (e.g., length prefix, special characters). * **Message Structure:** The format of the messages (e.g., JSON, Protocol Buffers, custom binary format). * **Error Handling:** How errors are reported and handled. * **Error Handling:** The example includes basic error handling, but you should implement more robust error handling in a production environment. * **Threading:** The example uses basic threading. For high-performance applications, consider using asynchronous I/O and thread pooling. * **Security:** This example does not include any security measures. In a real-world application, you'll need to implement appropriate security measures, such as authentication and authorization. * **Dependencies:** This example uses the standard .NET Core libraries. You may need to add additional dependencies depending on your specific requirements. **Code Example (C# .NET Core):** ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; namespace MCPEchoServer { class Program { static void Main(string[] args) { // Configuration int port = 12345; // Choose a port IPAddress ipAddress = IPAddress.Any; // Listen on all interfaces // Create a TCP listener TcpListener listener = new TcpListener(ipAddress, port); try { // Start listening listener.Start(); Console.WriteLine($"MCP Echo Server started, listening on {ipAddress}:{port}"); // Main loop: accept connections and handle them in separate threads while (true) { // Accept a pending connection. TcpClient client = listener.AcceptTcpClient(); // Create a new thread to handle the client. Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClient)); clientThread.Start(client); } } catch (Exception e) { Console.WriteLine($"Error: {e.Message}"); } finally { // Stop listening listener.Stop(); Console.WriteLine("MCP Echo Server stopped."); } } // Handles a single client connection. static void HandleClient(object obj) { TcpClient client = (TcpClient)obj; NetworkStream stream = client.GetStream(); try { Console.WriteLine($"Client connected: {client.Client.RemoteEndPoint}"); byte[] buffer = new byte[1024]; // Adjust buffer size as needed int bytesRead; // Read data from the client stream while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) > 0) { // Convert data to a string (assuming UTF-8 encoding) string receivedMessage = Encoding.UTF8.GetString(buffer, 0, bytesRead); Console.WriteLine($"Received: {receivedMessage}"); // **MCP Processing (Echo Service):** // In a real MCP implementation, you would parse the receivedMessage // according to the MCP specification and perform the appropriate action. // In this simple echo service, we just send the message back. // Echo the message back to the client byte[] sendData = Encoding.UTF8.GetBytes(receivedMessage); stream.Write(sendData, 0, sendData.Length); Console.WriteLine($"Sent: {receivedMessage}"); } Console.WriteLine($"Client disconnected: {client.Client.RemoteEndPoint}"); } catch (Exception e) { Console.WriteLine($"Error handling client: {e.Message}"); } finally { // Clean up stream.Close(); client.Close(); } } } } ``` **Explanation:** 1. **Namespaces:** Includes necessary namespaces for networking, threading, and text encoding. 2. **`Main` Method:** * Sets up the TCP listener on a specified port and IP address. * Starts listening for incoming connections. * Enters a loop to accept new client connections. * For each connection, it creates a new thread to handle the client. 3. **`HandleClient` Method:** * This method runs in a separate thread for each client. * Gets the network stream from the `TcpClient`. * Reads data from the client stream into a buffer. * Converts the received data to a string (assuming UTF-8 encoding). * **MCP Processing (Echo):** This is the core of the echo service. It simply takes the received message and sends it back to the client. In a real MCP implementation, this section would involve parsing the message according to the MCP specification and performing the appropriate action. * Sends the echoed message back to the client. * Handles exceptions and cleans up resources (closes the stream and client). **How to Run:** 1. **Create a new .NET Core Console Application project.** 2. **Copy and paste the code into your `Program.cs` file.** 3. **Build and run the application.** **Testing (using `netcat` or a similar tool):** 1. Open a terminal or command prompt. 2. Use `netcat` (or a similar tool) 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. **Key Improvements and Considerations for a Real MCP Implementation:** * **Message Framing:** Implement a robust message framing mechanism to ensure that messages are properly delimited. Common techniques include: * **Length Prefix:** Include a length field at the beginning of each message that indicates the size of the message body. * **Delimiter Characters:** Use special characters (e.g., `\r\n`, `\0`) to mark the end of a message. * **Message Serialization/Deserialization:** Use a serialization library (e.g., JSON.NET, Protocol Buffers, MessagePack) to serialize and deserialize messages. This will make it easier to handle complex data structures. * **Asynchronous I/O:** Use asynchronous I/O (`async` and `await`) to improve performance and scalability. This will allow the server to handle multiple clients concurrently without blocking. * **Thread Pooling:** Use the .NET thread pool to manage threads efficiently. This will avoid the overhead of creating and destroying threads for each client connection. * **Error Handling:** Implement comprehensive error handling to catch and log errors. Provide meaningful error messages to the client. * **Logging:** Use a logging framework (e.g., Serilog, NLog) to log events and errors. This will make it easier to debug and monitor the server. * **Configuration:** Use a configuration file to store settings such as the port number, IP address, and logging level. * **Security:** Implement appropriate security measures, such as authentication and authorization, to protect the server from unauthorized access. Consider using TLS/SSL to encrypt communication between the client and server. * **MCP Specification Adherence:** Ensure that your implementation strictly adheres to the MCP specification. This is crucial for interoperability with other MCP-compliant systems. This more detailed explanation and the improved code example should give you a solid foundation for building an MCP echo server in .NET Core. Remember to adapt the code to your specific MCP requirements.

Tempo Filler MCP Server

A Model Context Protocol server enabling AI assistants to interact with Tempo's time tracking system in JIRA for worklog retrieval, creation, and management.

funding-rates-mcp

funding-rates-mcp

mcp-servers

MCP servers to give super powers to LLMs

Trendy Post MCP

Enables users to take screenshots, extract text using OCR, and automatically generate trending Xiaohongshu-style social media posts. Combines image processing with AI-powered content generation to create engaging posts with hashtags and titles.

Rierino

Pengembangan middleware MCP low-code menggunakan arsitektur microservices untuk fungsionalitas server MCP yang terukur dan otomatis.

Google Indexing API MCP Server

An MCP server that enables interacting with Google's Indexing API, allowing agents to submit URLs to Google for indexing or removal from search results through natural language commands.

Alpha Vantage Stock Server

Sebuah server MCP untuk kueri Alpha Vantage API untuk informasi saham.

mcp-wordpress-instaWP

mcp-wordpress-instaWP