Discover Awesome MCP Servers

MCP Avantage

A Model Context Protocol server that enables LLMs to access comprehensive financial data from Alpha Vantage API, including stock prices, fundamentals, forex, crypto, and economic indicators.

Ghost MCP Server

A Model Context Protocol server that enables management of Ghost blog content (posts, pages, and tags) through the Ghost Admin API with SSE transport support.

SkyeNet-MCP-ACE

Enables AI agents to execute server-side JavaScript and perform CRUD operations directly on ServiceNow instances with context bloat reduction features for efficient token usage.

TeamCity MCP Server

Enables AI coding assistants to interact with JetBrains TeamCity CI/CD server through natural language commands. Supports triggering builds, monitoring status, analyzing test failures, and managing build configurations directly from development environments.

SRT Translation MCP Server

Enables processing and translating SRT subtitle files with intelligent conversation detection and context preservation. Supports parsing, validation, chunking of large files, and translation while maintaining precise timing and HTML formatting.

Speikzeug

Perangkat modern dengan integrasi server MCP untuk pemrosesan data otomatis dan anonimisasi sistem.

Cloudera Iceberg MCP Server (via Impala)

Cloudera Iceberg MCP Server melalui Impala

MCP-Gateway

MCP-Gateway adalah layanan yang menyediakan kemampuan manajemen terpadu MCP Server, membantu Agen AI terhubung dengan cepat ke berbagai sumber data. Melalui MCP Server, Agen AI dapat dengan mudah mengakses database, REST API, dan layanan eksternal lainnya tanpa perlu khawatir tentang detail koneksi spesifik.

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.

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.

Acknowledgments

Cermin dari

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.

MCP Server Collection

Layanan agregasi MCP

Pythagraph RED MCP Server

Enables retrieval and analysis of graph data from the Pythagraph RED API. Provides detailed graph statistics, node/edge distributions, and formatted table outputs for data visualization and analysis.

Formula1 MCP Server

Menyediakan data balap Formula 1 secara waktu nyata dan historis melalui Model Context Protocol, menawarkan akses ke data waktu, statistik pembalap, hasil balapan, telemetri, dan banyak lagi.

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.

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.

Github Mcp Server Review Tools

Memperluas GitHub MCP Server dengan alat tambahan untuk fungsionalitas komentar ulasan *pull request*.

funding-rates-mcp

funding-rates-mcp

GitHub MCP Server

Berikut adalah terjemahan dari teks tersebut ke dalam Bahasa Indonesia: **Server MCP GitHub dengan transportasi SSE yang dibangun dengan TypeScript dan Express** Atau, bisa juga: **Server MCP GitHub yang menggunakan transportasi SSE, dibuat dengan TypeScript dan Express** Kedua terjemahan tersebut menyampaikan arti yang sama. Pilihan mana yang lebih baik tergantung pada preferensi gaya Anda.

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.

Fatture in Cloud MCP Server

Enables integration with Fatture in Cloud to manage Italian electronic invoices through natural conversation, including creating, sending, and tracking invoices and financial data.