Discover Awesome MCP Servers

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.

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

Okay, here's a basic outline and code example for 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 structure the communication. This example focuses on a simple text-based echo service. **Conceptual Overview** * **MCP (Model Context Protocol):** In this context, I'm interpreting MCP as a protocol where the server maintains some kind of "model" or "context" related to the client's session. For a simple echo service, the "context" might just be the connection itself. More complex scenarios could involve storing user data, session state, etc. * **Echo Service:** The server receives data from the client and sends the exact same data back. * **.NET Core:** We'll use .NET Core for cross-platform compatibility and modern features. **Implementation Choices** * **Sockets:** I'll use raw sockets for the underlying communication. This gives you the most control. Alternatives include using ASP.NET Core Kestrel server (which is more suitable for HTTP-based MCP) or gRPC (which is more structured). * **Text-Based:** The echo service will handle text data. You can adapt it for binary data if needed. * **Single-Threaded (for simplicity):** The example will handle one client at a time. For production, you'll want to use threading or asynchronous operations to handle multiple clients concurrently. **Code Example (C# .NET Core)** ```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 IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port); // Create a TCP/IP socket. Socket listener = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); try { listener.Bind(localEndPoint); listener.Listen(10); // Listen with a backlog of 10 Console.WriteLine($"Server listening on port {port}"); while (true) { Console.WriteLine("Waiting for a connection..."); Socket handler = await listener.AcceptAsync(); // Accept incoming connection // Handle the client connection in a separate task (for concurrency in a real app) _ = Task.Run(() => HandleClient(handler)); } } catch (Exception e) { Console.WriteLine(e.ToString()); } Console.WriteLine("\nPress ENTER to continue..."); Console.Read(); } static async Task HandleClient(Socket handler) { string data = null; byte[] bytes = null; // Get the remote endpoint. Console.WriteLine($"Client connected: {handler.RemoteEndPoint}"); try { while (true) { bytes = new byte[1024]; // Buffer for incoming data int bytesRec = await handler.ReceiveAsync(new ArraySegment<byte>(bytes), SocketFlags.None); if (bytesRec == 0) { // Connection closed by client Console.WriteLine($"Client disconnected: {handler.RemoteEndPoint}"); break; } data += Encoding.ASCII.GetString(bytes, 0, bytesRec); // Echo the data back to the client. byte[] msg = Encoding.ASCII.GetBytes(data); await handler.SendAsync(new ArraySegment<byte>(msg), SocketFlags.None); Console.WriteLine($"Echoed: {data}"); data = null; // Reset data for the next message } } catch (Exception e) { Console.WriteLine($"Error handling client: {e.ToString()}"); } finally { handler.Shutdown(SocketShutdown.Both); handler.Close(); } } } } ``` **How to Run** 1. **Create a .NET Core Console Application:** Use `dotnet new console -o MCPEchoServer` 2. **Replace `Program.cs`:** Paste the code above into your `Program.cs` file. 3. **Run:** `dotnet run` **Explanation** 1. **Setup:** * Creates a `Socket` to listen for incoming connections. * Binds the socket to an IP address and port. * Starts listening for connections. 2. **Accepting Connections:** * The `AcceptAsync()` method asynchronously waits for a client to connect. * When a client connects, it returns a new `Socket` representing the connection to that client. 3. **Handling Clients (HandleClient):** * This method is responsible for communicating with a single client. * It enters a loop that: * Receives data from the client using `ReceiveAsync()`. * If `bytesRec` is 0, the client has closed the connection. * Converts the received bytes to a string using `Encoding.ASCII.GetString()`. * Echoes the data back to the client using `SendAsync()`. * Resets the `data` variable to prepare for the next message. * Includes error handling (try-catch) to catch exceptions during communication. * Closes the socket connection when the client disconnects or an error occurs. **Important Considerations and Improvements** * **Asynchronous Operations:** The code uses `async` and `await` for non-blocking I/O. This is crucial for handling multiple clients efficiently. The `Task.Run` is used to offload the `HandleClient` method to a separate thread, preventing the main thread from blocking while handling a client. * **Error Handling:** The `try-catch` blocks are essential for handling network errors (e.g., client disconnecting unexpectedly). * **Character Encoding:** The example uses `Encoding.ASCII`. Consider using `Encoding.UTF8` for better support of international characters. * **Buffering:** The `bytes` array is a fixed-size buffer. For larger messages, you might need to implement a more sophisticated buffering mechanism. * **Concurrency:** The `Task.Run` approach is a simple way to achieve concurrency. For more complex applications, consider using a thread pool, asynchronous streams, or other concurrency patterns. Be careful about shared state between threads. * **Protocol Definition:** This example uses a very simple "protocol" (just send text). For a real MCP, you'll need to define a more structured protocol for message framing, error handling, and potentially authentication/authorization. Consider using a library like `System.Text.Json` or `Newtonsoft.Json` for serializing and deserializing messages. * **Client Implementation:** You'll need a client application to connect to this server and send data. A simple client could be written using similar socket code. **Example Client (C# .NET Core)** ```csharp using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; namespace MCPEchoClient { class Program { static async Task Main(string[] args) { string serverAddress = "127.0.0.1"; // Replace with server's IP int port = 12345; try { IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(serverAddress), port); // Create a TCP/IP socket. Socket client = new Socket(IPAddress.Parse(serverAddress).AddressFamily, SocketType.Stream, ProtocolType.Tcp); // Connect to the remote endpoint. await client.ConnectAsync(remoteEP); Console.WriteLine($"Connected to {client.RemoteEndPoint}"); while (true) { Console.Write("Enter message (or 'exit' to quit): "); string message = Console.ReadLine(); if (message.ToLower() == "exit") { break; } // Send the data through the socket. byte[] msg = Encoding.ASCII.GetBytes(message); int bytesSent = await client.SendAsync(new ArraySegment<byte>(msg), SocketFlags.None); // Receive the response from the remote device. byte[] bytes = new byte[1024]; int bytesRec = await client.ReceiveAsync(new ArraySegment<byte>(bytes), SocketFlags.None); string response = Encoding.ASCII.GetString(bytes, 0, bytesRec); Console.WriteLine($"Received: {response}"); } // Release the socket. client.Shutdown(SocketShutdown.Both); client.Close(); } catch (Exception e) { Console.WriteLine(e.ToString()); } Console.WriteLine("\nPress ENTER to continue..."); Console.Read(); } } } ``` **To run the client:** 1. Create a new .NET Core console application. 2. Paste the client code into `Program.cs`. 3. Update `serverAddress` if necessary. 4. Run the client (`dotnet run`). **Vietnamese Translation of Key Concepts** * **Model Context Protocol (MCP):** Giao thức Ngữ cảnh Mô hình (Giao thức MCP) * **Echo Service:** Dịch vụ Phản hồi (hoặc Dịch vụ Lặp lại) * **Socket:** Ổ cắm (mạng) * **Client:** Máy khách * **Server:** Máy chủ * **Connection:** Kết nối * **Asynchronous:** Bất đồng bộ * **Thread:** Luồng * **Concurrency:** Tính đồng thời * **Buffer:** Bộ đệm * **Message:** Tin nhắn (hoặc Thông điệp) * **Protocol:** Giao thức * **Encoding:** Mã hóa * **Decoding:** Giải mã **Example Usage (Vietnamese)** 1. Chạy máy chủ (server). 2. Chạy máy khách (client). 3. Nhập một tin nhắn (message) vào máy khách và nhấn Enter. 4. Máy chủ sẽ phản hồi (echo) lại tin nhắn đó. This comprehensive example provides a solid foundation for building an MCP echo server in .NET Core. Remember to adapt and extend it based on the specific requirements of your application. Good luck!

MCP Document Processor

An intelligent document processing system that automatically classifies, extracts information from, and routes business documents using the Model Context Protocol (MCP).

Model Context Protocol Server

A stateful gateway server for AI applications that solves the memory limitations of Large Language Models by maintaining separate conversation contexts for each user.

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.

docx-comparison-mcp

Generates Word documents for comparison tables and specifications from structured JSON data. Supports both stdio mode for Claude Desktop/Code and HTTP mode for AI frameworks like Dify and LangFlow.

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.

local-memory-mcp

Description: Persistent local memory for Claude, Cursor and Codex. 13 MCP tools, SQLite + FTS5 + Knowledge Graph. No cloud, no API keys. One command: npx @studiomeyer/local-memory-mcp.

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.

DataForSEO MCP Server

Một máy chủ dựa trên stdio cho phép tương tác với DataForSEO API thông qua Giao thức Ngữ cảnh Mô hình (Model Context Protocol), cho phép người dùng lấy dữ liệu SEO bao gồm kết quả tìm kiếm, dữ liệu từ khóa, backlink, phân tích on-page và nhiều hơn nữa.

@semore/mcp-commerce

Reference MCP server for K-product cross-border commerce with five canonical tools for product search, cart creation, checkout quoting, and order submission.

Metaso MCP Server

Provides AI-powered web search, full-page content extraction, and search-enhanced Q\&A capabilities via the Metaso AI search engine. It enables large language models to access diverse information across web, academic, and multimedia sources with structured Markdown or JSON output.

Gallica/BnF MCP Server

Enables access to the Gallica digital library of the Bibliothèque nationale de France (BnF) with search capabilities across titles, authors, subjects, and dates, plus retrieval of document metadata, IIIF images, and OCR text content.

GitHub MCP Server in Go

Một triển khai không chính thức của máy chủ mcp cho github bằng go. Được sử dụng nội bộ tại Metoro.

Horse Racing News

Retrieves and displays the latest horse racing news stories from Thoroughbred Daily News RSS feed, including titles, content, and links.

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.

McpQualityAutocad

Validates AutoCAD VRD (Roads and Utilities) drawings against graphic standards through automated quality checks for layers, blocks, and conventions. Enables Claude to verify drawing compliance and generate quality reports.

SkillPort

A management toolkit for AI agent skills that provides an MCP server for search-first skill discovery and on-demand loading. It enables users to validate, organize, and serve standardized skills to MCP-compatible clients like Cursor and GitHub Copilot.

Theagora MCP Server

Enables AI agents to participate in a marketplace for buying, selling, and trading services with atomic escrow and cryptographic verification. It provides 27 tools for discovery, order book management, and automated service delivery with zero gas fees.

MCP-Ambari-API

Manage and monitor Hadoop clusters via Apache Ambari API, enabling service operations, configuration changes, status checks, and request tracking through a unified MCP interface for simplified administration. * Guide: https://call518.medium.com/llm-based-ambari-control-via-mcp-8668a2b5ffb9

ETHID MCP Server

Provides comprehensive access to the Ethereum Follow Protocol (EFP) API, enabling social graph queries, follower/following management, ENS resolution, and profile data retrieval for Ethereum addresses and ENS names.

focMCP SDK

Cung cấp các công cụ và cơ sở hạ tầng để xây dựng các máy chủ Minecraft Protocol hoàn toàn trên chuỗi, cho phép các nhà phát triển tạo ra các trải nghiệm chơi game phi tập trung bằng công nghệ blockchain.

SentinelGate

Open-source MCP proxy that enforces security policies, content scanning, and audit logging between AI agents and tool servers

Nager MCP v203 MCP Server

Provides access to the Nager.Date API through the Model Context Protocol, enabling AI agents to retrieve and interact with global public holiday data.

Agile Planner MCP Server

Automatically generates structured agile backlogs including epics, features, and user stories from natural language descriptions within AI-powered IDEs. It streamlines project management by creating AI-optimized markdown files and directory structures to guide step-by-step implementation.