Discover Awesome MCP Servers

Weather MCP Server

Enables AI assistants to retrieve real-time weather data and 5-day forecasts for any city using the OpenWeather API, supporting both metric and imperial units.

SEQ MCP Server

Enables LLMs to query and analyze logs from SEQ structured logging server with capabilities for searching events, retrieving event details, analyzing log patterns, and accessing saved searches.

Desktop MCP

Enables AI assistants to capture and analyze screen content across multi-monitor setups with smart image optimization. Provides screenshot capabilities and detailed monitor information for visual debugging, UI analysis, and desktop assistance.

Weather Java SSE Transport MCP Service

Máy chủ HTTP SSE Giao thức Ngữ cảnh Mô hình Java với Jetty

Hugging Face MCP Server

An MCP server that provides Hugging Face Hub API and Search endpoints through multiple transport protocols (STDIO, SSE, StreamableHTTP, and StreamableHTTPJson), enabling integration with AI model capabilities.

BugcrowdMCP

A high-performance Model Context Protocol server that provides secure, tool-based access to the Bugcrowd API, allowing for natural language interaction with bug bounty programs through various AI agent platforms.

Acknowledgments

Gương của

MCP Server Demo

A minimal Model Context Protocol server demo that exposes tools through HTTP API, including greeting, weather lookup, and HTTP request capabilities. Demonstrates MCP server implementation with stdio communication and HTTP gateway functionality.

Google PSE MCP Server

A Model Context Protocol server that enables LLM clients like VSCode, Copilot, and Claude Desktop to search the web using Google Programmable Search Engine API.

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!

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.

GitHub MCP Server

Máy chủ GitHub MCP với giao thức SSE được xây dựng bằng TypeScript và Express.

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

Phát triển middleware MCP mã nguồn thấp sử dụng kiến trúc microservices cho chức năng máy chủ MCP có khả năng mở rộng và tự động hóa.

MotaWord MCP Server

This MCP gives you full control over your translation projects from start to finish. You can log in anytime to see what stage your project is in — whether it’s being translated, reviewed, or completed.

MQScript MCP Server

Enables AI applications to generate and execute MQScript mobile automation scripts for controlling mobile devices. Supports touch operations, UI creation, color detection, file operations, and system control functions.

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

Một máy chủ MCP (Minecraft Protocol) truy vấn thông tin cổ phiếu bằng Alpha Vantage API.

Access Context Manager API MCP Server

An MCP server that provides access to Google's Access Context Manager API, enabling management of service perimeters and access levels through natural language.

OneTech MCP Server

Enables AI assistants to extract and document Mendix Studio Pro modules by interrogating local .mpr files. Generates comprehensive JSON documentation of domain models, pages, microflows, and enumerations without sending data to the cloud.

Reddit MCP Server

Provides access to Reddit's API for retrieving posts, comments, user information, and search functionality. Supports multiple authentication methods and comprehensive Reddit data operations including subreddit browsing, post retrieval, and user profile access.

Pinecone Economic Books

Enables semantic search through a Pinecone vector database containing economic books and academic papers using natural language queries. Provides 10 specialized search tools with metadata filtering for precise discovery of economic theories, concepts, and research by author, subject, or book.

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.

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.

go-mcp-server-mds

Dưới đây là bản dịch tiếng Việt của đoạn văn trên: Một triển khai bằng Go của máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol - MCP) phục vụ các tệp markdown có hỗ trợ frontmatter từ một hệ thống tệp.