Discover Awesome MCP Servers

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.

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.

Bright Data MCP Server

Enables AI agents to browse and extract data from any public website via Bright Data's cloud infrastructure, handling proxy rotation, CAPTCHA solving, and JavaScript rendering.

Agent Analytics MCP Server

Tracks and analyzes AI agent tool calls with event logging, dashboard, per-tool and per-agent analytics, and error monitoring.

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.

aptible-mcp

Enables interaction with the Aptible API for managing Aptible resources such as accounts, apps, and databases through natural language.

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.

PlanExe

Converts a plain-english goal into a structured plan document: Gantt chart, risk, stakeholders, SWOT, and role descriptions. A detailed first draft - expect to verify budgets and timelines before use.

Borsa MCP

Provides comprehensive access to Turkish and US financial markets data including BIST stocks, US equities, TEFAS funds, cryptocurrencies, forex, and commodities through 72 tools with technical analysis, financial statements, and Buffett-style value investing metrics.

MikroMCP

Production-grade MCP server for MikroTik RouterOS with secure AI-native network automation.

BnF API Server

Enables searching documents in Gallica, the digital library of the Bibliothèque nationale de France, and generating structured research reports with citations and images.

example-mcp-server-sse

example-mcp-server-sse

Obsidian Bonfires MCP

A hybrid MCP server that bridges Claude Desktop with both Obsidian vaults and the Bonfires platform, enabling seamless knowledge management and collaboration.

quotable-api-mcp

A Model Context Protocol (MCP) server template built with mcp-framework, providing a foundation for creating custom tools and publishing npm packages.

Notion MCP Server

AI-friendly MCP server for Notion API, enabling agents to search, read, query, and update Notion pages and databases with compact responses.

openresearch-mcp

Zero-auth multi-source research MCP server that enables web search, reading URLs, PDFs, GitHub repos, and querying Hacker News, Stack Overflow, Semantic Scholar, and YouTube transcripts without API keys.

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.

payclaw

Drop-in x402 payment middleware for MCP servers. Charge AI agents per tool call using USDC on Base chain — Python and JavaScript SDKs, no payment processor, no KYC.

telecom-ai

MCP server for telecom AI with built-in EU AI Act compliance, part of the MEOK AI Labs ecosystem.

Clockodo MCP Server

A TypeScript-based MCP server that integrates with the Clockodo time tracking API, enabling access to users, time entries, and projects.

QuickBooks Online MCP Server

A local MCP server that exposes QuickBooks Online data and actions as callable tools for AI assistants.

Xeams MCP Server

Enables email address validation and outbound email status checking for the Xeams on-premise email server via MCP tools.

nmap-mcp

An nmap MCP server for AI-assisted network security auditing, providing 14 purpose-built tools with structured JSON output.

React Patterns MCP Server

Provides React design and rendering patterns from patterns.dev as MCP tools and resources for Claude Code.

2D6 MCP

An AI GM assistant for tabletop RPGs that provides dice rolling, rules queries, and AI-powered rulings across multiple game systems including sci-fi, fantasy, and d20.

magic-api-mcp-server

Enables AI assistants to interact with Magic-API development environment, supporting script syntax query, API management, debugging, and knowledge search for efficient development.