{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {
    "cursor": "optional-cursor-value"
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [{
    "name": "get_weather",
    "description": "get current weather information for a location",
    "inputSchema": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "city name or zip code"
        }
      },
      "required": ["location"]
    }
  }],
  "nextCursor": "next-page-cursor"
  }
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "New York"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Current weather in New York:\nTemperature: 72°F\nConditions: Partly cloudy"
      }
    ],
    "isError": false
  }
}

from mcp.server.fastmcp import FastMCP
import sqlite3

mcp = FastMCP("SQLite Explorer")

@mcp.resource("schema://main")
def get_schema() -> str:
    """Provide the database schema as a resource"""
    conn = sqlite3.connect("database.db")
    schema = conn.execute(
        "SELECT sql FROM sqlite_master WHERE type='table'"
    ).fetchall()
    return "\n".join(sql[0] for sql in schema if sql[0])

@mcp.tool()
def query_data(sql: str) -> str:
    """Execute SQL queries safely"""
    conn = sqlite3.connect("database.db")
    try:
        result = conn.execute(sql).fetchall()
        return "\n".join(str(row) for row in result)
    except Exception as e:
        return f"Error: {str(e)}"

var clientOptions = new McpClientOptions()
{
  ClientInfo = new McpDotNet.Protocol.Types.Implementation() 
  { 
    Name = name, Version = "1.0.0" 
  },
};

var serverConfig = new McpServerConfig()
{
  Id = "playwright",
  Name = "playwright",
  TransportType = "stdio",
  TransportOptions = new Dictionary<string, string>
  {
    ["command"] = "npx",
    ["arguments"] = "-y @executeautomation/playwright-mcp-server",
  }
};

var loggerFactory = kernel.Services.GetRequiredService<ILoggerFactory>();
var clientFactory = new McpClientFactory(
  [serverConfig], 
  clientOptions, 
  NullLoggerFactory.Instance
);

var client = await clientFactory.GetClientAsync(serverConfig.Id).ConfigureAwait(false);

var listToolsResult = await client.ListToolsAsync().ConfigureAwait(false);
var tools = listToolsResult.Tools;

// 将 MCP 中的 Tool 转换为 KernelFunction
private static KernelFunction ToKernelFunction(this Tool tool, IMcpClient client) {
  async Task<string> InvokeToolAsync(
    Kernel kernel, 
    KernelFunction function, 
    KernelArguments arguments, 
    CancellationToken cancellationToken
  ) {
    try {
      var mcpArguments = new Dictionary<string, object>();
      foreach (var arg in arguments) {
        if (arg.Value is not null) 
          mcpArguments[arg.Key] = function.ToArgumentValue(arg.Key, arg.Value);
      }

      var result = await client.CallToolAsync(
        tool.Name,
        mcpArguments,
        cancellationToken: cancellationToken
      ).ConfigureAwait(false);

      return string.Join("\n", result.Content
        .Where(c => c.Type == "text")
        .Select(c => c.Text));
      } catch {
        throw;
      }
  }

  return KernelFunctionFactory.CreateFromMethod(
    method: InvokeToolAsync,
    functionName: tool.Name,
    description: tool.Description,
    parameters: ToKernelParameters(tool),
    returnParameter: ToKernelReturnParameter()
  );
}

// 将 MCP 中工具的输入转换为 KernelFunction 输入
private static List<KernelParameterMetadata> ToKernelParameters(Tool tool) {
  var inputSchema = tool.InputSchema;
  var properties = inputSchema?.Properties;
  if (properties == null) return [];

  HashSet<string> requiredProperties = new(inputSchema!.Required ?? []);
  return properties.Select(kvp => new KernelParameterMetadata(kvp.Key) {
    Description = kvp.Value.Description,
    ParameterType = ConvertParameterDataType(kvp.Value, requiredProperties.Contains(kvp.Key)),
    IsRequired = requiredProperties.Contains(kvp.Key)
  })
  .ToList();
}

// 将 JSONSchema 中的数据类型转换为 C# 的数据类型
private static Type ConvertParameterDataType(JsonSchemaProperty property, bool required) {
  var type = property.Type switch {
    "string" => typeof(string),
    "integer" => typeof(int),
    "number" => typeof(double),
    "boolean" => typeof(bool),
    "array" => typeof(List<string>),
    "object" => typeof(Dictionary<string, object>),
    _ => typeof(object)
  };

  return !required && type.IsValueType ? typeof(Nullable<>).MakeGenericType(type) : type;
}

// 转换返回值，简化处理，直接返回字符串类型
private static KernelReturnParameterMetadata? ToKernelReturnParameter() {
  return new KernelReturnParameterMetadata() {
    ParameterType = typeof(string),
  };
}

// 将 KernelFunction 参数转换为 object
private static object ToArgumentValue(this KernelFunction function, string name, object value) {
  var parameter = function.Metadata.Parameters.FirstOrDefault(p => p.Name == name);
  return parameter?.ParameterType switch
  {
    Type t when Nullable.GetUnderlyingType(t) == typeof(int) => Convert.ToInt32(value),
    Type t when Nullable.GetUnderlyingType(t) == typeof(double) => Convert.ToDouble(value),
    Type t when Nullable.GetUnderlyingType(t) == typeof(bool) => Convert.ToBoolean(value),
    Type t when t == typeof(List<string>) => (value as IEnumerable<object>)?.ToList(),
    Type t when t == typeof(Dictionary<string, object>) => (value as Dictionary<string, object>)?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value),
    _ => value,
  } ?? value;
}

public static async Task<IEnumerable<KernelFunction>> GetKernelFunctionsAsync(this IMcpClient client) {
  var listToolsResult = await client.ListToolsAsync().ConfigureAwait(false);
  return listToolsResult.Tools.Select(tool => ToKernelFunction(tool, client)).ToList();
}

var result = await client.CallToolAsync(
  tool.Name,
  mcpArguments,
  cancellationToken: cancellationToken
).ConfigureAwait(false);

// 注册 MCP Server
public static async Task AddMCPServer(
  this Kernel kernel, string name, string command, 
  string version = "1.0.0", 
  string[] args = null, 
  Dictionary<string, string> env = null
  ) {
    var clientOptions = new McpClientOptions() {
        ClientInfo = new McpDotNet.Protocol.Types.Implementation() { 
          Name = name, Version = "1.0.0" 
        },
    };

    var serverConfig = new McpServerConfig() {
        Id = name,
        Name = name,
        TransportType = "stdio",
        TransportOptions = new Dictionary<string, string> {
            ["command"] = command,
            ["arguments"] = string.Join(' ', args ?? []),
        }
    };

    var loggerFactory = kernel.Services.GetRequiredService<ILoggerFactory>();
    var clientFactory = new McpClientFactory([serverConfig], clientOptions, loggerFactory);

    var client = await clientFactory.GetClientAsync(serverConfig.Id).ConfigureAwait(false);
    var kernelFunctions = await client.GetKernelFunctionsAsync();
    kernel.Plugins.AddFromFunctions(name, kernelFunctions);
}

// 添加 playwright-mcp-server
await kernel.AddMCPServer(
  name: "playwright",
  command: "npx",
  version: "1.0.0",
  args: ["-y", "@executeautomation/playwright-mcp-server"],
  env: null
);