Modell-Kontext-Protokoll

Es ist möglich, Anwendungen zu erstellen, die Agentenmodellen Kontext mithilfe großer Sprachmodelle (LLMs) bereitstellen, und zwar mit dem Paket Sisk.ModelContextProtocol :

dotnet add package Sisk.ModelContextProtocol --prerelease

Dieses Paket stellt nützliche Klassen und Methoden zum Aufbau von MCP‑Servern bereit, die über Streamable HTTP arbeiten und einzelne Anfrage‑/Antwort‑Nachrichten unterstützen. Seit Version 1.7.0‑rc1 unterstützt es zustandslose Anfragen der Protokollversion 2026-07-28 und behält den Legacy‑Initialisierungsablauf für Clients bei, die die Versionen 2025-11-25, 2025-06-18 und 2025-03-26 verwenden. Es unterstützt Werkzeuge und Skills.

Hinweis

Bevor Sie beginnen, beachten Sie bitte, dass dieses Paket sich noch in der Entwicklung befindet und Verhaltensweisen zeigen kann, die nicht der Spezifikation entsprechen. Lesen Sie die Paketdetails, um zu erfahren, was sich noch in Entwicklung befindet und was noch nicht funktioniert.

Erste Schritte mit MCP #

Die Klasse McpProvider ist der Einstiegspunkt zur Definition eines MCP‑Servers. Es handelt sich um ein versiegeltes Provider‑Objekt, das beim Start konfiguriert werden kann. Ihre Sisk‑Anwendung kann einen oder mehrere MCP‑Provider besitzen.

McpProvider mcp = new McpProvider(
    serverName: "math-server",
    serverTitle: "Mathematics server",
    serverVersion: new Version(1, 0));

mcp.Tools.Add(new McpTool(
    name: "math_sum",
    description: "Sums one or more numbers.",
    schema: JsonSchema.CreateObjectSchema(
        properties: new Dictionary<string, JsonSchema>()
        {
            { "numbers",
                JsonSchema.CreateArraySchema(
                    itemsSchema: JsonSchema.CreateNumberSchema(),
                    minItems: 1,
                    description: "The numbers to sum.")
            }
        },
        requiredProperties: ["numbers"]),
    executionHandler: async (McpToolContext context) =>
    {
        var numbers = context.Arguments["numbers"].GetJsonArray().ToArray<double>();
        var sum = numbers.Sum();
        return await Task.FromResult(McpToolResult.CreateText($"Sum result: {sum:N4}"));
    }));

Wenn Ihre Anwendung nur einen MCP‑Provider bereitstellt, können Sie das Singleton des Builders verwenden:

static void Main(string[] args)
{
    using var host = HttpServer.CreateBuilder()
        .UseMcp(mcp =>
        {
            mcp.ServerName = "math-server";
            mcp.ServerTitle = "Mathematics server";

            mcp.Tools.Add(new McpTool(
                name: "math_sum",
                description: "Sums one or more numbers.",
                schema: JsonSchema.CreateObjectSchema(
                    properties: new Dictionary<string, JsonSchema>()
                    {
                        { "numbers",
                            JsonSchema.CreateArraySchema(
                                itemsSchema: JsonSchema.CreateNumberSchema(),
                                minItems: 1,
                                description: "The numbers to sum.")
                        }
                    },
                    requiredProperties: ["numbers"]),
                executionHandler: async (McpToolContext context) =>
                {
                    var numbers = context.Arguments["numbers"].GetJsonArray().ToArray<double>();
                    var sum = numbers.Sum();
                    return await Task.FromResult(McpToolResult.CreateText($"Sum result: {sum:N4}"));
                }));
        })
        .UseRouter(router =>
        {
            router.MapAny("/mcp", async (HttpRequest req) =>
            {
                return await req.HandleMcpRequestAsync();
            });
        })
        .Build();

    host.Start();
}

Der Endpunkt muss sowohl GET‑ als auch POST‑Anfragen akzeptieren, daher ist MapAny die einfachste Routen‑Zuordnung. HandleMcpRequestAsync gibt eine HttpResponse zurück, und Ihre Route muss diese zurückgeben. Wenn Sie mehrere Provider in einer Anwendung benötigen, überspringen Sie das Singleton und rufen Sie McpProvider.HandleRequestAsync direkt aus jeder Route auf:

var mathProvider = new McpProvider("math-server", "Mathematics server", new Version(1, 0));

router.MapAny("/mcp/math", async request =>
{
    return await mathProvider.HandleRequestAsync(request);
});

Erstellen von JSON-Schemas für Funktionen #

Die Bibliothek [Sisk.ModelContextProtocol] verwendet einen Fork von LightJson für die Manipulation von JSON und JSON‑Schemas. Diese Implementierung bietet einen fluenten JSON‑Schema‑Builder für verschiedene Objekte:

JsonSchema.CreateObjectSchema
JsonSchema.CreateArraySchema
JsonSchema.CreateBooleanSchema
JsonSchema.CreateNumberSchema
JsonSchema.CreateStringSchema
JsonSchema.Empty

Beispiel:

JsonSchema.CreateObjectSchema(
    properties: new Dictionary<string, JsonSchema>()
    {
        { "numbers",
            JsonSchema.CreateArraySchema(
                itemsSchema: JsonSchema.CreateNumberSchema(),
                minItems: 1,
                description: "The numbers to sum.")
        }
    },
    requiredProperties: ["numbers"]);

Erzeugt das folgende Schema:

JSON

{
  "type": "object",
  "properties": {
    "numbers": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "minItems": 1,
      "description": "The numbers to sum."
    }
  },
  "required": ["numbers"]
}

Umgang mit Funktionsaufrufen #

Die im Parameter executionHandler von McpTool definierte Funktion liefert ein JsonObject, das die Aufrufargumente enthält und das fluently gelesen werden kann:

mcp.Tools.Add(new McpTool(
    name: "browser_do_action",
    description: "Run an browser action, such as scrolling, refreshing or navigating.",
    schema: JsonSchema.CreateObjectSchema(
        properties: new Dictionary<string, JsonSchema>()
        {
            { "action_name",
                JsonSchema.CreateStringSchema(
                    enums: ["go_back", "refresh", "scroll_bottom", "scroll_top"],
                    description: "The action name.")
            },
            { "action_data",
                JsonSchema.CreateStringSchema(
                    description: "Action parameter."
                ) }
        },
        requiredProperties: ["action_name"]),
    executionHandler: async (McpToolContext context) =>
    {
        // Lese den Aktionsnamen. Wirft eine Ausnahme, wenn null oder kein expliziter String
        string actionName = context.Arguments["action_name"].GetString();
        
        // action_data ist als nicht erforderlich definiert, daher kann es hier null sein
        string? actionData = context.Arguments["action_data"].MaybeNull()?.GetString();
        
        // Verarbeite die Browseraktion basierend auf dem actionName
        return await Task.FromResult(
            McpToolResult.CreateText($"Performed browser action: {actionName}"));
    }));

Tool‑Argumente werden vor dem Aufruf Ihres Handlers anhand des Schemas validiert. Bei einer fehlgeschlagenen Validierung gibt der Provider ein Fehlergebnis an den MCP‑Client zurück und ruft den Tool‑Handler nicht auf.

Funktionsresultate #

Das Objekt McpToolResult stellt drei Methoden zum Erzeugen von Inhalten für eine Tool‑Antwort bereit:

CreateAudio(ReadOnlySpan, string): erstellt eine audio‑basierte Antwort für den MCP‑Client.
CreateImage(ReadOnlySpan, string): erstellt eine bild‑basierte Antwort für den MCP‑Client.
CreateText(string): erstellt eine text‑basierte Antwort (Standard) für den MCP‑Client.

Zusätzlich ist es möglich, mehrere unterschiedliche Inhalte zu einer einzigen JSON‑Tool‑Antwort zu kombinieren:

mcp.Tools.Add(new McpTool(
    ...
    executionHandler: async (McpToolContext context) =>
    {
        // simulate real work

        byte[] browserScreenshot = await browser.ScreenshotAsync();
        
        return McpToolResult.Combine(
            McpToolResult.CreateText("Heres the screenshot of the browser:"),
            McpToolResult.CreateImage(browserScreenshot, "image/png")
        )
    }));

Der Provider unterstützt derzeit server/discover, die Legacy‑Methoden initialize und ping, tools/list, tools/call, skills/list, skills/get, resources/list, resources/read sowie Benachrichtigungen. Nicht unterstützte JSON‑RPC‑Methoden liefern eine JSON‑RPC‑Fehlerantwort.

Veröffentlichen von Skills #

Ein MCP‑Provider kann außerdem Agent Skills über die Erweiterung io.modelcontextprotocol/skills veröffentlichen. Fügen Sie McpSkill-Objekte zu McpProvider.Skills hinzu, bevor der Provider beginnt, Anfragen zu bearbeiten:

mcp.Skills.Add(new McpSkill(
    path: "acme/refunds",
    frontmatter: new JsonObject
    {
        ["name"] = "refunds",
        ["description"] = "Follow the refund workflow."
    },
    body: "# Refunds\nRead references/policy.md before using the refund tools.",
    files: new Dictionary<string, byte[]>
    {
        ["references/policy.md"] = File.ReadAllBytes("skills/refunds/references/policy.md")
    }));

McpSkill erzeugt die Datei SKILL.md aus dem Frontmatter und dem Markdown‑Body. Das letzte Segment von path muss dem Feld name im Frontmatter entsprechen. Die Skill‑Dateien werden beim Erstellen des Skills kopiert und vom Provider nie wieder von der Festplatte gelesen. Clients listen und lesen Skills mit skills/list, skills/get und resources/read unter Verwendung der Protokollversion 2026-07-28. Siehe die Paketdetails für Limits und Validierungsregeln.

Weiterführende Arbeit #

Das Model Context Protocol ist ein Kommunikationsprotokoll für Agentenmodelle und Anwendungen, die Inhalte für diese bereitstellen. Es ist ein neues Protokoll, sodass seine Spezifikation häufig mit Deprecations, neuen Features und Breaking Changes aktualisiert wird.

Es ist entscheidend, die Probleme zu verstehen, die das Model Context Protocol löst, bevor Sie mit dem Bau von Agenten‑Anwendungen beginnen.

Lesen Sie außerdem die Spezifikation des Sisk.ModelContextProtocol-Pakets, um dessen Fortschritt, Status und mögliche Anwendungsbereiche zu verstehen.