Now that we’ve explored how to leverage Model Context Protocol (MCP) servers to utilize external Tools and AI models in C# applications, how to write your own Standard Input/Output (STDIO) MCP server in C# using the modelcontextprotocol / csharp-sdk, and how we can dockerize your .NET C# MCP server to be able to distribute it for use by AI clients. It’s time to take a step further and explore how to leverage Server-Sent Events (SSE) MCP servers so that we can deploy them remotely, for example on a Raspberry Pi.

Introduction

Model Context Protocol (MCP) is a protocol that allows AI models to communicate with external tools and services. It supports different transport protocols, including STDIO and SSE. In this post, we will explore how to create a simple SSE-powered MCP server using C# and .NET. We will also discuss how to publish the server so that we could run it on a Raspberry Pi.

Create a Simple SSE-Powered MCP Server

To create a simple SSE-powered MCP server, we will use the modelcontextprotocol / csharp-sdk library. This library provides a simple way to create an MCP server and now supports SSE.

dotnet new web -n MCPSSEServer
cd MCPSSEServer
dotnet add package ModelContextProtocol.AspNetCore --version 0.1.0-preview.6

Open your Program.cs file and add the following code:

using MCPSSEServer;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

builder.Services
    // 👇 Add MCP Server to IoC
    .AddMcpServer()
    // 👇 Register MCP Tool
    .WithTools<TimeTool>();

var app = builder.Build();

// 👇 Map Mcp endpoints
app.MapMcp();

app.Run();

This code creates a simple ASP.NET Core web application that uses the ModelContextProtocol.AspNetCore library to create an MCP server. The WithTools<TimeTool>() method registers a simple tool that returns the current time, as we saw in all previous posts. It’s not very different from the STDIO MCP server we created in the previous post.

The TimeTool class is defined as follows:

using System.ComponentModel;
using ModelContextProtocol.Server;

namespace MCPSSEServer;

[McpServerToolType]
public class TimeTool
{
    // 👇 Mark a method as an MCP tools
    [McpServerTool, Description("Get the current time for a city")]
    public static string GetCurrentTime(string city) => 
        $"It is {DateTime.Now.Hour:00}:{DateTime.Now.Minute:00} in {city}.";
}

Running the SSE MCP Server

To run the MCP server, you can use the following command:

dotnet run

This will start the server and you should see the following output:

info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5000
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: D:\projects\tmp\MCPSSEServer

We can test the server by sending a request to the /sse endpoint using any web browser. You should see a similar output:

event: endpoint
data: /message?sessionId=J6962mKVVKDZYbIiRGT1RQ

The MCP server is now running and ready to accept requests. You can use any MCP client to send requests to the server.

Publish the MCP Server

The modelcontextprotocol / csharp-sdk library was made Native ahead-of-time (AOT) compatible. This means that we can publish the MCP server as a self-contained application, ahead-of-time compiled to native code. These apps can run on machines that don’t have the .NET runtime installed. Native AOT applications target a specific runtime environment, such as Linux x64 or Windows x64.

We extend the csproj file to add the following properties:

<PropertyGroup>
  <!-- 👇🏼 Enables Native AOT compilation during publish-->
  <PublishAot>true</PublishAot>
  <!-- 👇🏼 Favor the size of the executable instead of other performance -->
  <OptimizationPreference>Size</OptimizationPreference>
</PropertyGroup>

To publish the MCP server, you can use the following command from a Windows machine:

dotnet publish

And you will get a single Windows exe file MCPSSEServer.exe of 15.7 MB 😲!

To be able to run the MCP server on a Raspberry Pi, we need to publish it for Linux ARM64. To achieve that goal, you need to publish from the Raspberry Pi, because cross-OS native compilation is not supported. It should work without any problem; nevertheless, I haven’t tested it yet.

Using our MCP server

To use the MCP server, we can use Claude, Visual Studio Code, or any other client supporting MCP with SSE.

You can configure Visual Studio Code by adding the following configuration to your settings.json file:

"servers": {
    "laurent-mcp-server": {
        "type": "sse",
        "url": "http://localhost:5000/sse",
        "env": {}
    }    
}

Claude Desktop currently doesn’t support SSE, but you can use a proxy with the following addition to the claude_desktop_config.json file:

{
  "mcpServers": {
    "math": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:5000/sse"
      ]
    }
  }
}

You can read more about how to configure and use both Claude and Visual Studio Code in my previous post Dockerizing your .NET C# MCP Server for AI Clients like Claude Desktop.

Conclusion

In this post, we explored how to create a simple SSE-powered MCP server using C# and .NET. The SSE protocol, compared to STDIO, allows us to deploy the MCP Server on a remote machine. We also discussed how to publish the server as a self-contained, ahead-of-time compiled native code application. This allows us to run the MCP server on machines that don’t have the .NET runtime installed, creating quite small executables.

Get the source code on GitHub aiPlayground/MCPSSEServer and if you like it please give it a star ⭐️.

laurentkempe/aiPlayground

Some experiments around AI to learn.