最新DeepSeek-V3驱动的MCP与SemanticKernel实战教程 - 打造智能应用的终极指南

简单介绍

在进入教程之前我们可以先对MCP进行一个大概的了解，MCP是什么？为什么要用MCP？MCP和Function Calling有什么区别？
MCP是什么？

Model Context Protocol (MCP) 是一个开放协议，它使 LLM 应用与外部数据源和工具之间的无缝集成成为可能。无论你是构建 AI 驱动的 IDE、改善 chat 交互，还是构建自定义的 AI 工作流，MCP 提供了一种标准化的方式，将 LLM 与它们所需的上下文连接起来。

• MCP Hosts: 想要通过MCP访问数据的程序，如Claude Desktop、ide或AI工具
  
• MCP Clients: 与服务器保持1:1连接的协议客户端
  
• MCP Servers: 轻量级程序，每个程序都通过标准化的模型上下文协议公开特定的功能
  
• Local Data Sources: MCP服务器可以安全访问的计算机文件、数据库和服务
  
• Remote Services: MCP服务器可以连接的internet上可用的外部系统（例如通过api）
  

为什么要用MCP?

• 扩展LLM的能力：让模型能够访问最新数据、专有信息和本地资源
  
• 数据私密性和安全性：数据可以保留在本地或受控环境中，减少敏感信息共享的风险
  
• 工具集成：使LLM能够调用和控制外部工具，扩展其功能范围
  
• 减少幻觉：通过提供准确的上下文信息，降低模型生成虚假内容的可能性
  
• 标准化：为开发者提供一致的接口，简化集成过程
  
• 可扩展性：支持从简单用例到复杂企业级应用的多种场景
  
• 跨语言的能力：通过标准的MCP协议我们可以使用不同语言提供的MCPServer的能力
  

MCP和Function Calling有什么区别？

我听过最多人问的就是MCP和Function Calling有什么区别？
特性MCPFunction Calling基础关系基于Function Calling构建并扩展作为MCP的基础技术设计范围更广泛的协议，处理上下文获取和工具使用主要聚焦于调用特定函数架构客户端-服务器架构，支持分布式系统通常是API参数的直接定义和调用数据处理可以处理大型数据集和复杂上下文主要处理结构化的函数参数和返回值上下文管理专门设计用于管理和提供上下文上下文管理不是核心功能标准化程度开放协议，旨在跨不同系统和模型标准化实现方式因平台而异，标准化程度较低应用场景适用于需要复杂上下文和工具集成的场景适用于调用预定义函数执行特定任务简而言之，MCP（Model Context Protocol）是在Function Calling基础上发展而来的更全面的协议，它不仅保留了Function Calling的核心功能，还扩展了上下文获取和管理能力，为LLM提供更丰富、更标准化的环境交互能力。
开始MCPClient基础教程

前提条件，您需要先将上一个教程的MCPServer跑起来一会才能进行当前步骤，因为MCPClient是需要MCPServer提供Tools，下面我默认您已经运行了MCPServer，
然后可以访问 https://account.coreshub.cn/signup?invite=ZmpMQlZxYVU= 获取免费的DeepSeek-V3模型和白嫖GPU服务器，通过上面连接注册以后访问
https://console.coreshub.cn/xb3/maas/global-keys/ 地址获取到APIKey
然后记住我们的APIKey，开始下面的旅途

• 创建属于您的MCPClient程序
  

创建一个McpClient的控制台项目

给项目添加依赖包

1.     <ItemGroup>
2.         <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.3" />
3.         <PackageReference Include="Microsoft.SemanticKernel" Version="1.44.0" />
4.         <PackageReference Include="ModelContextProtocol" Version="0.1.0-preview.4" />
5.     </ItemGroup>

复制代码

下面的教程我们将使用Microsoft.SemanticKernel开发，然后依赖ModelContextProtocol官方的包，然后我们需要用到Microsoft.Extensions.Hosting
开始我们的代码开发

• 扩展SemanticKernel的MCPClient
  

由于SemnaticKernel默认是不能直接使用MCP的功能，那么我们需要先对它进行扩展
创建几个基础类
JsonSchema.cs

1. /// <summary>
2. /// Represents a JSON schema for a tool's input arguments.
3. /// <see href="https://github.com/modelcontextprotocol/specification/blob/main/schema/2024-11-05/schema.json">See the schema for details</see>
4. /// </summary>
5. internal class JsonSchema
6. {
7.     /// <summary>
8.     /// The type of the schema, should be "object".
9.     /// </summary>
10.     [JsonPropertyName("type")]
11.     public string Type { get; set; } = "object";
13.     /// <summary>
14.     /// Map of property names to property definitions.
15.     /// </summary>
16.     [JsonPropertyName("properties")]
17.     public Dictionary<string, JsonSchemaProperty>? Properties { get; set; }
19.     /// <summary>
20.     /// List of required property names.
21.     /// </summary>
22.     [JsonPropertyName("required")]
23.     public List<string>? Required { get; set; }
24. }
25. JsonSchemaProperty.cs
26. /// <summary>
27. /// Represents a property in a JSON schema.
28. /// <see href="https://github.com/modelcontextprotocol/specification/blob/main/schema/2024-11-05/schema.json">See the schema for details</see>
29. /// </summary>
30. internal class JsonSchemaProperty
31. {
32.     /// <summary>
33.     /// The type of the property. Should be a JSON Schema type and is required.
34.     /// </summary>
35.     [JsonPropertyName("type")]
36.     public string Type { get; set; } = string.Empty;
38.     /// <summary>
39.     /// A human-readable description of the property.
40.     /// </summary>
41.     [JsonPropertyName("description")]
42.     public string? Description { get; set; } = string.Empty;
43. }

复制代码

接下来创建MCP的扩展类，用于将MCPFunction进行转换成SemanticKernel Function
ModelContextProtocolExtensions.cs

1. /// <summary>
2. /// Extension methods for ModelContextProtocol
3. /// </summary>
4. internal static class ModelContextProtocolExtensions
5. {
6.     /// <summary>
7.     /// Map the tools exposed on this <see cref="IMcpClient"/> to a collection of <see cref="KernelFunction"/> instances for use with the Semantic Kernel.
8.     /// <param name="mcpClient">The <see cref="IMcpClient"/>.</param>
9.     /// <param name="cancellationToken">The optional <see cref="CancellationToken"/>.</param>
10.     /// </summary>
11.     internal static async Task<IReadOnlyList<KernelFunction>> MapToFunctionsAsync(this IMcpClient mcpClient, CancellationToken cancellationToken = default)
12.     {
13.         var functions = new List<KernelFunction>();
14.         foreach (var tool in await mcpClient.ListToolsAsync(cancellationToken).ConfigureAwait(false))
15.         {
16.             functions.Add(tool.ToKernelFunction(mcpClient, cancellationToken));
17.         }
19.         return functions;
20.     }
22.     private static KernelFunction ToKernelFunction(this McpClientTool tool, IMcpClient mcpClient, CancellationToken cancellationToken)
23.     {
24.         async Task<string> InvokeToolAsync(Kernel kernel, KernelFunction function, KernelArguments arguments, CancellationToken ct)
25.         {
26.             try
27.             {
28.                 // Convert arguments to dictionary format expected by ModelContextProtocol
29.                 Dictionary<string, object?> mcpArguments = [];
30.                 foreach (var arg in arguments)
31.                 {
32.                     if (arg.Value is not null)
33.                     {
34.                         mcpArguments[arg.Key] = function.ToArgumentValue(arg.Key, arg.Value);
35.                     }
36.                 }
38.                 // Call the tool through ModelContextProtocol
39.                 var result = await mcpClient.CallToolAsync(
40.                     tool.Name,
41.                     mcpArguments.AsReadOnly(),
42.                     cancellationToken: ct
43.                 ).ConfigureAwait(false);
45.                 // Extract the text content from the result
46.                 return string.Join("\n", result.Content
47.                     .Where(c => c.Type == "text")
48.                     .Select(c => c.Text));
49.             }
50.             catch (Exception ex)
51.             {
52.                 await Console.Error.WriteLineAsync($"Error invoking tool '{tool.Name}': {ex.Message}");
54.                 // Rethrowing to allow the kernel to handle the exception
55.                 throw;
56.             }
57.         }
59.         return KernelFunctionFactory.CreateFromMethod(
60.             method: InvokeToolAsync,
61.             functionName: tool.Name,
62.             description: tool.Description,
63.             parameters: tool.ToParameters(),
64.             returnParameter: ToReturnParameter()
65.         );
66.     }
68.     private static object ToArgumentValue(this KernelFunction function, string name, object value)
69.     {
70.         var parameterType = function.Metadata.Parameters.FirstOrDefault(p => p.Name == name)?.ParameterType;
72.         if (parameterType == null)
73.         {
74.             return value;
75.         }
77.         if (Nullable.GetUnderlyingType(parameterType) == typeof(int))
78.         {
79.             return Convert.ToInt32(value);
80.         }
82.         if (Nullable.GetUnderlyingType(parameterType) == typeof(double))
83.         {
84.             return Convert.ToDouble(value);
85.         }
87.         if (Nullable.GetUnderlyingType(parameterType) == typeof(bool))
88.         {
89.             return Convert.ToBoolean(value);
90.         }
92.         if (parameterType == typeof(List<string>))
93.         {
94.             return (value as IEnumerable<object>)?.ToList() ?? value;
95.         }
97.         if (parameterType == typeof(Dictionary<string, object>))
98.         {
99.             return (value as Dictionary<string, object>)?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value) ?? value;
100.         }
102.         return value;
103.     }
105.     private static List<KernelParameterMetadata>? ToParameters(this McpClientTool tool)
106.     {
107.         var inputSchema = JsonSerializer.Deserialize<JsonSchema>(tool.JsonSchema.GetRawText());
108.         var properties = inputSchema?.Properties;
109.         if (properties == null)
110.         {
111.             return null;
112.         }
114.         HashSet<string> requiredProperties = [.. inputSchema!.Required ?? []];
115.         return properties.Select(kvp =>
116.             new KernelParameterMetadata(kvp.Key)
117.             {
118.                 Description = kvp.Value.Description,
119.                 ParameterType = ConvertParameterDataType(kvp.Value, requiredProperties.Contains(kvp.Key)),
120.                 IsRequired = requiredProperties.Contains(kvp.Key)
121.             }).ToList();
122.     }
124.     private static KernelReturnParameterMetadata ToReturnParameter()
125.     {
126.         return new KernelReturnParameterMetadata
127.         {
128.             ParameterType = typeof(string),
129.         };
130.     }
132.     private static Type ConvertParameterDataType(JsonSchemaProperty property, bool required)
133.     {
134.         var type = property.Type switch
135.         {
136.             "string" => typeof(string),
137.             "integer" => typeof(int),
138.             "number" => typeof(double),
139.             "boolean" => typeof(bool),
140.             "array" => typeof(List<string>),
141.             "object" => typeof(Dictionary<string, object>),
142.             _ => typeof(object)
143.         };
145.         return !required && type.IsValueType ? typeof(Nullable<>).MakeGenericType(type) : type;
146.     }
147. }

复制代码

然后创建SemanticKernel的扩展，对SKFunction进行扩展
KernelExtensions.cs

1. /// <summary>
2. /// Extension methods for KernelPlugin
3. /// </summary>
4. public static class KernelExtensions
5. {
6.     private static readonly ConcurrentDictionary<string, IKernelBuilderPlugins> SseMap = new();
8.     /// <summary>
9.     /// Creates a Model Content Protocol plugin from an SSE server that contains the specified MCP functions and adds it into the plugin collection.
10.     /// </summary>
11.     /// <param name="endpoint"></param>
12.     /// <param name="serverName"></param>
13.     /// <param name="cancellationToken">The optional <see cref="CancellationToken"/>.</param>
14.     /// <param name="plugins"></param>
15.     /// <returns>A <see cref="KernelPlugin"/> containing the functions.</returns>
16.     public static async Task<IKernelBuilderPlugins> AddMcpFunctionsFromSseServerAsync(this IKernelBuilderPlugins plugins,
17.         string endpoint, string serverName, CancellationToken cancellationToken = default)
18.     {
19.         var key = ToSafePluginName(serverName);
21.         if (SseMap.TryGetValue(key, out var sseKernelPlugin))
22.         {
23.             return sseKernelPlugin;
24.         }
26.         var mcpClient = await GetClientAsync(serverName, endpoint, null, null, cancellationToken).ConfigureAwait(false);
27.         var functions = await mcpClient.MapToFunctionsAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
29.         cancellationToken.Register(() => mcpClient.DisposeAsync().ConfigureAwait(false).GetAwaiter().GetResult());
31.         sseKernelPlugin = plugins.AddFromFunctions(key, functions);
32.         return SseMap[key] = sseKernelPlugin;
33.     }
35.     private static async Task<IMcpClient> GetClientAsync(string serverName, string? endpoint,
36.         Dictionary<string, string>? transportOptions, ILoggerFactory? loggerFactory,
37.         CancellationToken cancellationToken)
38.     {
39.         var transportType = !string.IsNullOrEmpty(endpoint) ? TransportTypes.Sse : TransportTypes.StdIo;
41.         McpClientOptions options = new()
42.         {
43.             ClientInfo = new()
44.             {
45.                 Name = $"{serverName} {transportType}Client",
46.                 Version = "1.0.0"
47.             }
48.         };
50.         var config = new McpServerConfig
51.         {
52.             Id = serverName.ToLowerInvariant(),
53.             Name = serverName,
54.             Location = endpoint,
55.             TransportType = transportType,
56.             TransportOptions = transportOptions
57.         };
59.         return await McpClientFactory.CreateAsync(config, options,
60.             loggerFactory: loggerFactory ?? NullLoggerFactory.Instance, cancellationToken: cancellationToken);
61.     }
63.     // A plugin name can contain only ASCII letters, digits, and underscores.
64.     private static string ToSafePluginName(string serverName)
65.     {
66.         return Regex.Replace(serverName, @"[^\w]", "_");
67.     }
68. }

复制代码

• 实现连接MCPServer的Tools
  

现在我们就可以实现核心的代码了，打开我们的Program.cs

1. using McpClient;
2. using Microsoft.SemanticKernel;
3. using Microsoft.SemanticKernel.ChatCompletion;
4. using Microsoft.SemanticKernel.Connectors.OpenAI;
5. using ChatMessageContent = Microsoft.SemanticKernel.ChatMessageContent;
7. #pragma warning disable SKEXP0010
9. var builder = Host.CreateEmptyApplicationBuilder(settings: null);
11. builder.Configuration
12.     .AddEnvironmentVariables()
13.     .AddUserSecrets<Program>();
15. var kernelBuilder = builder.Services.AddKernel()
16.     .AddOpenAIChatCompletion("DeepSeek-V3", new Uri("https://openapi.coreshub.cn/v1"), "您使用的https://openapi.coreshub.cn/v1平台的APIKey");
18. await kernelBuilder.Plugins.AddMcpFunctionsFromSseServerAsync("http://您的MCPServerip:端口/sse", "token");
20. Console.ForegroundColor = ConsoleColor.Green;
21. Console.WriteLine("MCP Client Started!");
22. Console.ResetColor();
24. var app = builder.Build();
26. var kernel = app.Services.GetService<Kernel>();
27. var chatCompletion = app.Services.GetService<IChatCompletionService>();
29. PromptForInput();
30. while (Console.ReadLine() is string query && !"exit".Equals(query, StringComparison.OrdinalIgnoreCase))
31. {
32.     if (string.IsNullOrWhiteSpace(query))
33.     {
34.         PromptForInput();
35.         continue;
36.     }
38.     var history = new ChatHistory
39.     {
40.         new ChatMessageContent(AuthorRole.System, "下面如果需要计算俩个数的和，请使用我提供的工具。"),
41.         new ChatMessageContent(AuthorRole.User, query)
42.     };
44.     await foreach (var message in chatCompletion?.GetStreamingChatMessageContentsAsync(history,
45.                        new OpenAIPromptExecutionSettings()
46.                        {
47.                            ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions,
48.                        }, kernel))
49.     {
50.         Console.Write(message.Content);
51.     }
53.     Console.WriteLine();
55.     PromptForInput();
56. }
58. static void PromptForInput()
59. {
60.     Console.WriteLine("Enter a command (or 'exit' to quit):");
61.     Console.ForegroundColor = ConsoleColor.Cyan;
62.     Console.Write("> ");
63.     Console.ResetColor();
64. }

复制代码

然后开始启动我们的MCPClient，在此之前需要先修改代码中的参数改成自己的，然后先启动MCPServer以后，在启动我们的MCPClient
执行以后提问1+1=?然后会得到一下的结果

在执行之前我们可以先在MCPServer中的算法函数Debug，这样就可以清晰的看到进入的流程了

通过上面的案例，恭喜您您已经熟练的掌握了MCPServer+MCPClient+SemanticKernel的入门级教程

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！