Everything server

ModelContextProtocol.sln

@@ -50,6 +50,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuickstartWeatherServer", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuickstartClient", "samples\QuickstartClient\QuickstartClient.csproj", "{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EverythingServer", "samples\EverythingServer\EverythingServer.csproj", "{17B8453F-AB72-99C5-E5EA-D0B065A6AE65}"
+EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ModelContextProtocol.AspNetCore", "src\ModelContextProtocol.AspNetCore\ModelContextProtocol.AspNetCore.csproj", "{37B6A5E0-9995-497D-8B43-3BC6870CC716}"
 EndProject
 Global
@@ -94,6 +96,10 @@ Global
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{17B8453F-AB72-99C5-E5EA-D0B065A6AE65}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{17B8453F-AB72-99C5-E5EA-D0B065A6AE65}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{17B8453F-AB72-99C5-E5EA-D0B065A6AE65}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{17B8453F-AB72-99C5-E5EA-D0B065A6AE65}.Release|Any CPU.Build.0 = Release|Any CPU
 		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -113,6 +119,7 @@ Global
 		{0C6D0512-D26D-63D3-5019-C5F7A657B28C} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{4653EB0C-8FC0-98F4-E9C8-220EDA7A69DF} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{17B8453F-AB72-99C5-E5EA-D0B065A6AE65} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{37B6A5E0-9995-497D-8B43-3BC6870CC716} = {A2F1F52A-9107-4BF8-8C3F-2F6670E7D0AD}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution

samples/EverythingServer/EverythingServer.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
+  </ItemGroup>
+
+</Project>

samples/EverythingServer/LoggingUpdateMessageSender.cs

@@ -0,0 +1,43 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using ModelContextProtocol;
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Server;
+
+namespace EverythingServer;
+
+public class LoggingUpdateMessageSender(IMcpServer server, Func<LoggingLevel> currentLevel) : BackgroundService
+{
+    readonly Dictionary<LoggingLevel, string> _loggingLevelMap = new()
+    {
+        { LoggingLevel.Debug, "Debug-level message" },
+        { LoggingLevel.Info, "Info-level message" },
+        { LoggingLevel.Notice, "Notice-level message" },
+        { LoggingLevel.Warning, "Warning-level message" },
+        { LoggingLevel.Error, "Error-level message" },
+        { LoggingLevel.Critical, "Critical-level message" },
+        { LoggingLevel.Alert, "Alert-level message" },
+        { LoggingLevel.Emergency, "Emergency-level message" }
+    };
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            var newLevel = (LoggingLevel)Random.Shared.Next(_loggingLevelMap.Count);
+
+            var message = new
+                {
+                    Level = newLevel.ToString().ToLower(),
+                    Data = _loggingLevelMap[newLevel],
+                };
+
+            if (newLevel > currentLevel())
+            {
+                await server.SendNotificationAsync("notifications/message", message, cancellationToken: stoppingToken);
+            }
+
+            await Task.Delay(15000, stoppingToken);
+        }
+    }
+}

samples/EverythingServer/Program.cs

@@ -0,0 +1,195 @@
+using EverythingServer;
+using EverythingServer.Prompts;
+using EverythingServer.Tools;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol;
+using ModelContextProtocol.Protocol.Types;
+using ModelContextProtocol.Server;
+
+var builder = Host.CreateApplicationBuilder(args);
+builder.Logging.AddConsole(consoleLogOptions =>
+{
+    // Configure all logs to go to stderr
+    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
+});
+
+HashSet<string> subscriptions = [];
+var _minimumLoggingLevel = LoggingLevel.Debug;
+
+builder.Services
+    .AddMcpServer()
+    .WithStdioServerTransport()
+    .WithTools<AddTool>()
+    .WithTools<AnnotatedMessageTool>()
+    .WithTools<EchoTool>()
+    .WithTools<LongRunningTool>()
+    .WithTools<PrintEnvTool>()
+    .WithTools<SampleLlmTool>()
+    .WithTools<TinyImageTool>()
+    .WithPrompts<ComplexPromptType>()
+    .WithPrompts<SimplePromptType>()
+    .WithListResourceTemplatesHandler((ctx, ct) =>
+    {
+        return Task.FromResult(new ListResourceTemplatesResult
+        {
+            ResourceTemplates =
+            [
+                new ResourceTemplate { Name = "Static Resource", Description = "A static resource with a numeric ID", UriTemplate = "test://static/resource/{id}" }
+            ]
+        });
+    })
+    .WithReadResourceHandler((ctx, ct) =>
+    {
+        var uri = ctx.Params?.Uri;
+
+        if (uri is null || !uri.StartsWith("test://static/resource/"))
+        {
+            throw new NotSupportedException($"Unknown resource: {uri}");
+        }
+
+        int index = int.Parse(uri["test://static/resource/".Length..]) - 1;
+
+        if (index < 0 || index >= ResourceGenerator.Resources.Count)
+        {
+            throw new NotSupportedException($"Unknown resource: {uri}");
+        }
+
+        var resource = ResourceGenerator.Resources[index];
+
+        if (resource.MimeType == "text/plain")
+        {
+            return Task.FromResult(new ReadResourceResult
+            {
+                Contents = [new TextResourceContents
+                {
+                    Text = resource.Description!,
+                    MimeType = resource.MimeType,
+                    Uri = resource.Uri,
+                }]
+            });
+        }
+        else
+        {
+            return Task.FromResult(new ReadResourceResult
+            {
+                Contents = [new BlobResourceContents
+                {
+                    Blob = resource.Description!,
+                    MimeType = resource.MimeType,
+                    Uri = resource.Uri,
+                }]
+            });
+        }
+    })
+    .WithSubscribeToResourcesHandler(async (ctx, ct) =>
+    {
+        var uri = ctx.Params?.Uri;
+
+        if (uri is not null)
+        {
+            subscriptions.Add(uri);
+
+            await ctx.Server.RequestSamplingAsync([
+                new ChatMessage(ChatRole.System, "You are a helpful test server"),
+                new ChatMessage(ChatRole.User, $"Resource {uri}, context: A new subscription was started"),
+            ],
+            options: new ChatOptions
+            {
+                MaxOutputTokens = 100,
+                Temperature = 0.7f,
+            },
+            cancellationToken: ct);
+        }
+
+        return new EmptyResult();
+    })
+    .WithUnsubscribeFromResourcesHandler((ctx, ct) =>
+    {
+        var uri = ctx.Params?.Uri;
+        if (uri is not null)
+        {
+            subscriptions.Remove(uri);
+        }
+        return Task.FromResult(new EmptyResult());
+    })
+    .WithGetCompletionHandler((ctx, ct) =>
+    {
+        var exampleCompletions = new Dictionary<string, IEnumerable<string>>
+        {
+            { "style", ["casual", "formal", "technical", "friendly"] },
+            { "temperature", ["0", "0.5", "0.7", "1.0"] },
+            { "resourceId", ["1", "2", "3", "4", "5"] }
+        };
+
+        var @ref = ctx.Params?.Ref;
+
+        if (@ref is null)
+        {
+            throw new NotSupportedException($"Reference is required.");
+        }
+
+        var argument = ctx.Params!.Argument;
+
+        if (@ref.Type == "ref/resource")
+        {
+            var resourceId = @ref.Uri?.Split("/").Last();
+
+            if (resourceId is null)
+            {
+                return Task.FromResult(new CompleteResult());
+            }
+
+            var values = exampleCompletions["resourceId"].Where(id => id.StartsWith(argument.Value));
+
+            return Task.FromResult(new CompleteResult
+            {
+                Completion = new Completion { Values = [..values], HasMore = false, Total = values.Count() }
+            });
+        }
+
+        if (@ref.Type == "ref/prompt")
+        {
+            if (!exampleCompletions.TryGetValue(argument.Name, out IEnumerable<string>? value))
+            {
+                throw new NotSupportedException($"Unknown argument name: {argument.Name}");
+            }
+
+            var values = value.Where(value => value.StartsWith(argument.Value));
+            return Task.FromResult(new CompleteResult
+            {
+                Completion = new Completion { Values = [..values], HasMore = false, Total = values.Count() }
+            });
+        }
+
+        throw new NotSupportedException($"Unknown reference type: {@ref.Type}");
+    })
+    .WithSetLoggingLevelHandler(async (ctx, ct) =>
+    {
+        if (ctx.Params?.Level is null)
+        {
+            throw new McpServerException("Missing required argument 'level'");
+        }
+
+        _minimumLoggingLevel = ctx.Params.Level;
+
+        await ctx.Server.SendNotificationAsync("notifications/message", new
+            {
+                Level = "debug",
+                Logger = "test-server",
+                Data = $"Logging level set to {_minimumLoggingLevel}",
+            }, cancellationToken: ct);
+
+        return new EmptyResult();
+    })
+    ;
+
+builder.Services.AddSingleton(subscriptions);
+builder.Services.AddHostedService<SubscriptionMessageSender>();
+builder.Services.AddHostedService<LoggingUpdateMessageSender>();
+
+builder.Services.AddSingleton<Func<LoggingLevel>>(_ => () => _minimumLoggingLevel);
+
+await builder.Build().RunAsync();

samples/EverythingServer/Prompts/ComplexPromptType.cs

@@ -0,0 +1,22 @@
+using EverythingServer.Tools;
+using Microsoft.Extensions.AI;
+using ModelContextProtocol.Server;
+using System.ComponentModel;
+
+namespace EverythingServer.Prompts;
+
+[McpServerPromptType]
+public class ComplexPromptType
+{
+    [McpServerPrompt(Name = "complex_prompt"), Description("A prompt with arguments")]
+    public static IEnumerable<ChatMessage> ComplexPrompt(
+        [Description("Temperature setting")] int temperature,
+        [Description("Output style")] string? style = null)
+    {
+        return [
+            new ChatMessage(ChatRole.User,$"This is a complex prompt with arguments: temperature={temperature}, style={style}"),
+            new ChatMessage(ChatRole.Assistant, "I understand. You've provided a complex prompt with temperature and style arguments. How would you like me to proceed?"),
+            new ChatMessage(ChatRole.User, [new DataContent(TinyImageTool.MCP_TINY_IMAGE)])
+        ];
+    }
+}

samples/EverythingServer/Prompts/SimplePromptType.cs

@@ -0,0 +1,11 @@
+using ModelContextProtocol.Server;
+using System.ComponentModel;
+
+namespace EverythingServer.Prompts;
+
+[McpServerPromptType]
+public class SimplePromptType
+{
+    [McpServerPrompt(Name = "simple_prompt"), Description("A prompt without arguments")]
+    public static string SimplePrompt() => "This is a simple prompt without arguments";
+}

samples/EverythingServer/ResourceGenerator.cs

@@ -0,0 +1,37 @@
+using ModelContextProtocol.Protocol.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace EverythingServer;
+
+static class ResourceGenerator
+{
+    private static readonly List<Resource> _resources = Enumerable.Range(1, 100).Select(i =>
+        {
+            var uri = $"test://static/resource/{i}";
+            if (i % 2 != 0)
+            {
+                return new Resource
+                {
+                    Uri = uri,
+                    Name = $"Resource {i}",
+                    MimeType = "text/plain",
+                    Description = $"Resource {i}: This is a plaintext resource"
+                };
+            }
+            else
+            {
+                var buffer = System.Text.Encoding.UTF8.GetBytes($"Resource {i}: This is a base64 blob");
+                return new Resource
+                {
+                    Uri = uri,
+                    Name = $"Resource {i}",
+                    MimeType = "application/octet-stream",
+                    Description = Convert.ToBase64String(buffer)
+                };
+            }
+        }).ToList();
+
+    public static IReadOnlyList<Resource> Resources => _resources;
+}

samples/EverythingServer/SubscriptionMessageSender.cs

@@ -0,0 +1,23 @@
+using Microsoft.Extensions.Hosting;
+using ModelContextProtocol;
+using ModelContextProtocol.Server;
+
+internal class SubscriptionMessageSender(IMcpServer server, HashSet<string> subscriptions) : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            foreach (var uri in subscriptions)
+            {
+                await server.SendNotificationAsync("notifications/resource/updated",
+                    new
+                    {
+                        Uri = uri,
+                    }, cancellationToken: stoppingToken);
+            }
+
+            await Task.Delay(5000, stoppingToken);
+        }
+    }
+}

samples/EverythingServer/Tools/AddTool.cs

@@ -0,0 +1,11 @@
+using ModelContextProtocol.Server;
+using System.ComponentModel;
+
+namespace EverythingServer.Tools;
+
+[McpServerToolType]
+public class AddTool
+{
+    [McpServerTool(Name = "add"), Description("Adds two numbers.")]
+    public static string Add(int a, int b) => $"The sum of {a} and {b} is {a + b}";
+}