MCPSharp Documentation

To expose a .NET method as an MCP tool, create a class and decorate the method with the [McpTool] attribute. You can also use [McpParameter] to provide metadata like descriptions and requirement status for individual parameters. Note that [McpFunction] is deprecated; use [McpTool] instead.

using MCPSharp;

public class Calculator
{
    [McpTool("add", "Adds two numbers")]
    public static int Add([McpParameter(true)] int a, [McpParameter(true)] int b)
    {
        return a + b;
    }
}

To use MCPSharp in your .NET project, add the NuGet package using the dotnet CLI.

dotnet add package MCPSharp

To expose Semantic Kernel functions as MCP tools, decorate your class methods with the [KernelFunction] attribute and then explicitly register the class with the MCP server using MCPServer.Register<T>().

using Microsoft.SemanticKernel;

public class MySkillClass
{
    [KernelFunction("MyFunction")]
    [Description("Description of my function")]
    public string MyFunction(string input) => $"Processed: {input}$";
}

// Register with MCPServer
MCPServer.Register<MySkillClass>();

MCPSharp can automatically extract tool descriptions and parameter metadata from your C# XML comments. To enable this, you must set <GenerateDocumentationFile>true</GenerateDocumentationFile> in your project file.

<PropertyGroup>
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <NoWarn>$(NoWarn);1591</NoWarn>
</PropertyGroup>

You can connect to an MCP server using MCPClient and convert its tools into AIFunction objects. This allows you to plug MCP tools directly into the ChatOptions.Tools property of any IChatClient implementation.

// Client-side integration
MCPClient client = new("AIClient", "1.0", "path/to/mcp/server");
IList<AIFunction> functions = await client.GetFunctionsAsync();

If you need to register tools at runtime with custom implementation logic rather than using attributes, use MCPServer.AddToolHandler. This requires defining a Tool object with a name, description, and InputSchema, along with a delegate that handles the execution.

MCPServer.AddToolHandler(new Tool() 
{
    Name = "dynamicTool",
    Description = "A dynamic tool",
    InputSchema = new InputSchema {
        Type = "object",
        Required = ["input"],
        Properties = new Dictionary<string, ParameterSchema>{
            {"input", new ParameterSchema{Type="string", Description="Input value"}}
        }
    }
}, (string input) => { return $"You provided: {input}"; });

Use MCPServer.StartAsync(string serverName, string version) to start the server. By default, it automatically discovers methods marked with [McpTool] in the base assembly. To register tools from a different library or class, use MCPServer.Register<T>().

await MCPServer.StartAsync("CalculatorServer", "1.0.0");

Attributes used to define MCP capabilities on classes and methods.

// [McpTool]
// Marks a class or method as an MCP tool.
// Parameters:
// - Name: The tool name (default: class/method name)
// - Description: Description of the tool

// [McpParameter]
// Provides metadata for function parameters.
// Parameters:
// - Description: Parameter description
// - Required: Whether the parameter is required (default: false)

// [McpResource]
// Marks a property or method as an MCP resource.
// Parameters:
// - Name: Resource name
// - Uri: Resource URI (can include templates)
// - MimeType: MIME type of the resource
// - Description: Resource description

Core methods for managing the MCP server lifecycle and interacting with MCP clients.

// Server Methods
// MCPServer.StartAsync(string serverName, string version)
// MCPServer.Register<T>()
// MCPServer.AddToolHandler(Tool tool, Delegate func)

// Client Methods
// new MCPClient(string name, string version, string server, string args = null, IDictionary<string, string> env = null)
// client.GetToolsAsync()
// client.CallToolAsync(string name, Dictionary<string, object> parameters)
// client.GetResourcesAsync()
// client.GetFunctionsAsync()