---

.NET nanoFramework WebServer with Model Context Protocol (MCP)

Build status

Component	Build Status	NuGet Package
nanoFramework.WebServer
nanoFramework.WebServer.FileSystem
nanoFramework.WebServer.Mcp

Overview

This library provides a lightweight, multi-threaded HTTP/HTTPS WebServer for .NET nanoFramework with comprehensive Model Context Protocol (MCP) support for AI agent integration.

Key Features

• Multi-threaded request handling
• Static file serving with FileSystem support
• RESTful API support with parameter handling
• Route-based controllers with attribute decoration
• Authentication support (Basic, API Key)
• HTTPS/SSL support with certificates
• Model Context Protocol (MCP) for AI agent integration
• Automatic tool discovery and JSON-RPC 2.0 compliance

Quick Start

Basic Event Based WebServer

Using the Web Server is very straight forward and supports event based calls.

// You need to be connected to a wifi or ethernet connection with a proper IP Address

using (WebServer server = new WebServer(80, HttpProtocol.Http))
{
    server.CommandReceived += ServerCommandReceived;
    server.Start();
    Thread.Sleep(Timeout.Infinite);
}

private static void ServerCommandReceived(object source, WebServerEventArgs e)
{
    if (e.Context.Request.RawUrl.ToLower() == "/hello")
    {
        WebServer.OutPutStream(e.Context.Response, "Hello from nanoFramework!");
    }
    else
    {
        WebServer.OutputHttpCode(e.Context.Response, HttpStatusCode.NotFound);
    }
}

Controller-Based WebServer

Controllers are supported including with parametarized routes like api/led/{id}/dosomething/{order}.

using (WebServer server = new WebServer(80, HttpProtocol.Http, new Type[] { typeof(MyController) }))
{
    server.Start();
    Thread.Sleep(Timeout.Infinite);
}

public class MyController
{
    [Route("api/hello")]
    [Method("GET")]
    public void Hello(WebServerEventArgs e)
    {
        WebServer.OutPutStream(e.Context.Response, "Hello from Controller!");
    }

    [Route("api/led/{id}")]
    [Method("GET")]
    public void LedState(WebServerEventArgs e)
    {
        string ledId = e.GetRouteParameter("id");
        WebServer.OutPutStream(e.Context.Response, $"You selected Led {ledId}!");
    }
}

Model Context Protocol (MCP) Support

Enable AI agents to interact with your embedded devices through standardized tools and JSON-RPC 2.0 protocol.

Defining MCP Tools

public class IoTTools
{
    [McpServerTool("read_sensor", "Reads temperature from sensor")]
    public static string ReadTemperature()
    {
        // Your sensor reading code
        return "23.5°C";
    }

    [McpServerTool("control_led", "Controls device LED", "Uutput the statusof the LED")]
    public static string ControlLed(LedCommand command)
    {
        // Your LED control code
        return $"LED set to {command.State}";
    }
}

public class LedCommand
{
    [Description("LED state: on, off, or blink")]
    public string State { get; set; }
}

Setting Up MCP Server

public static void Main()
{
    // Connect to WiFi first
    var connected = WifiNetworkHelper.ConnectDhcp(Ssid, Password, requiresDateTime: true);
    
    // Discover and register MCP tools
    McpToolRegistry.DiscoverTools(new Type[] { typeof(IoTTools) });
    
    // Start WebServer with MCP support
    using (var server = new WebServer(80, HttpProtocol.Http, new Type[] { typeof(McpServerController) }))
    {
        // Optional customization
        McpServerController.ServerName = "MyIoTDevice";
        McpServerController.Instructions = "IoT device with sensor and LED control capabilities.";
        
        server.Start();
        Thread.Sleep(Timeout.Infinite);
    }
}

AI Agent Integration

Once running, AI agents can discover and invoke your tools:

// Tool discovery
POST /mcp
{
    "jsonrpc": "2.0",
    "method": "tools/list",
    "id": 1
}

// Tool invocation
POST /mcp
{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
        "name": "control_led",
        "arguments": {"State": "on"}
    },
    "id": 2
}

Documentation

Topic	Description
Controllers and Routing	Learn about route attributes, method decorations, and URL parameters
Authentication	Configure Basic Auth, API Key, and custom authentication
HTTPS and Certificates	Set up SSL/TLS encryption with certificates
File System Support	Serve static files from storage devices
Model Context Protocol (MCP)	Complete MCP guide for AI agent integration
REST API Development	Build RESTful APIs with request/response handling
Event-Driven Programming	Handle requests through events and status monitoring
Examples and Samples	Working examples and code samples

Limitations

• No compression support in request/response streams
• MCP implementation supports server features only (no notifications or SSE)
• No or single parameter limitation for MCP tools (use complex objects for multiple parameters)

Installation

Install nanoFramework.WebServer for the Web Server without File System support. Install nanoFramework.WebServer.FileSystem for file serving, so with devices supporting File System. Install nanoFramework.WebServer.Mcp for MCP support. It does contains the full nanoFramework.WebServer but does not include native file serving. You can add this feature fairly easilly by reusing the code function serving it.

Contributing

For documentation, feedback, issues and contributions, please refer to the Home repo.

Join our Discord community here.

Credits

The list of contributors to this project can be found at CONTRIBUTORS.

License

Licensed under the MIT license.

Code of Conduct

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behaviour in our community. For more information see the .NET Foundation Code of Conduct.

.NET Foundation

This project is supported by the .NET Foundation.