Semantic Kernel 和 Kernel Memory，工良出品，超简单的教程
万字长文学会对接 AI 模型：Semantic Kernel 和 Kernel Memory，工良出品，超简单的教程目录
[*]万字长文学会对接 AI 模型：Semantic Kernel 和 Kernel Memory，工良出品，超简单的教程
[*]配置环境
[*]部署 one-api
[*]配置项目环境
[*]模型划分和应用场景
[*]聊天
[*]提示词
[*]引导 AI 回复
[*]指定 AI 回复特定格式
[*]模板化提示
[*]聊天记录
[*]函数和插件
[*]直接调用插件函数
[*]提示模板文件
[*]根据 AI 自动调用插件函数
[*]聊天中明确调用函数
[*]实现总结
[*]配置提示词
[*]提示模板语法
[*]变量
[*]函数调用
[*]文本生成
[*]Semantic Kernel 插件
[*]文档插件
[*]planners
[*]Kernel Memory 构建文档知识库
[*]从 web 处理网页
[*]手动处理文档
AI 越来越火了，所以给读者们写一个简单的入门教程，希望喜欢。
很多人想学习 AI，但是不知道怎么入门。笔者开始也是，先是学习了 Python，然后是 Tensorflow ，还准备看一堆深度学习的书。但是逐渐发现，这些知识太深奥了，无法在短时间内学会。此外还有另一个问题，学这些对自己有什么帮助？虽然学习这些技术是很 NB，但是对自己作用有多大？自己到底需要学什么？
这这段时间，接触了一些需求，先后搭建了一些聊天工具和 Fastgpt 知识库平台，经过一段时间的使用和研究之后，开始确定了学习目标，是能够做出这些应用。而做出这些应用是不需要深入学习 AI 相关底层知识的。
所以，AI 的知识宇宙非常庞大，那些底层的细节我们可能无法探索，但是并不重要，我们只需要能够做出有用的产品即可。基于此，本文的学习重点在于 Semantic Kernel 和 Kernel Memory 两个框架，我们学会这两个框架之后，可以编写聊天工具、知识库工具。
配置环境
要学习本文的教程也很简单，只需要有一个 Open AI、Azure Open AI 即可，甚至可以使用国内百度文心。
下面我们来了解如何配置相关环境。
部署 one-api
部署 one-api 不是必须的，如果有 Open AI 或 Azure Open AI 账号，可以直接跳过。如果因为账号或网络原因不能直接使用这些 AI 接口，可以使用国产的 AI 模型，然后使用 one-api 转换成 Open AI 格式接口即可。
one-api 的作用是支持各种大厂的 AI 接口，比如 Open AI、百度文心等，然后在 one-api 上创建一层新的、与 Open AI 一致的。这样一来开发应用时无需关注对接的厂商，不需要逐个对接各种 AI 模型，大大简化了开发流程。
one-api 开源仓库地址：https://github.com/songquanpeng/one-api
界面预览：
下载官方仓库：
git clone https://github.com/songquanpeng/one-api.git
文件目录如下：
. ├── bin ├── common ├── controller ├── data ├── docker-compose.yml ├── Dockerfile ├── go.mod ├── go.sum ├── i18n ├── LICENSE ├── logs ├── main.go ├── middleware ├── model ├── one-api.service ├── pull_request_template.md ├── README.en.md ├── README.ja.md ├── README.md ├── relay ├── router ├── VERSION └── web
one-api 需要依赖 redis、mysql ，在 docker-compose.yml 配置文件中有详细的配置，同时 one-api 默认管理员账号密码为 root、123456，也可以在此修改。
执行 docker-compose up -d 开始部署 one-api，然后访问 3000 端口，进入管理系统。
进入系统后，首先创建渠道，渠道表示用于接入大厂的 AI 接口。
为什么有模型重定向和自定义模型呢。
比如，笔者的 Azure Open AI 是不能直接选择使用模型的，而是使用模型创建一个部署，然后通过指定的部署使用模型，因此在 api 中不能直接指定使用 gpt-4-32k 这个模型，而是通过部署名称使用，在模型列表中选择可以使用的模型，而在模型重定向中设置部署的名称。
然后在令牌中，创建一个与 open ai 官方一致的 key 类型，外部可以通过使用这个 key，从 one-api 的 api 接口中，使用相关的 AI 模型。
one-api 的设计，相对于一个代理平台，我们可以通过后台接入自己账号的 AI 模型，然后创建二次代理的 key 给其他人使用，可以在里面配置每个账号、key 的额度。
创建令牌之后复制和保存即可。
使用 one-api 接口时，只需要使用 http://192.0.0.1:3000/v1 格式作为访问地址即可，后面需不需要加 /v1 视情况而定，一般需要携带。
配置项目环境
创建一个 BaseCore 项目，在这个项目中复用重复的代码，编写各种示例时可以复用相同的代码，引入 Microsoft.SemanticKernel 包。
因为开发时需要使用到密钥等相关信息，因此不太好直接放到代码里面，这时可以使用环境变量或者 json 文件存储相关私密数据。
以管理员身份启动 powershell 或 cmd，添加环境变量后立即生效，不过需要重启 vs。
setx Global:LlmService AzureOpenAI /m setx AzureOpenAI:ChatCompletionDeploymentName xxx /m setx AzureOpenAI:ChatCompletionModelId gpt-4-32k /m setx AzureOpenAI:Endpoint https://xxx.openai.azure.com /m setx AzureOpenAI:ApiKey xxx /m
或者在 appsettings.json 配置。
{ "Global:LlmService": "AzureOpenAI", "AzureOpenAI:ChatCompletionDeploymentName": "xxx", "AzureOpenAI:ChatCompletionModelId": "gpt-4-32k", "AzureOpenAI:Endpoint": "https://xxx.openai.azure.com", "AzureOpenAI:ApiKey": "xxx" }
然后在 Env 文件中加载环境变量或 json 文件，读取其中的配置。
public static class Env { public static IConfiguration GetConfiguration() { var configuration = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .AddEnvironmentVariables() .Build(); return configuration; } }
模型划分和应用场景
在学习开发之前，我们需要了解一下基础知识，以便可以理解编码过程中关于模型的一些术语，当然，在后续编码过程中，笔者也会继续介绍相应的知识。
以 Azure Open AI 的接口为例，以以下相关的函数：
虽然这些接口都是连接到 Azure Open AI 的，但是使用的是不同类型的模型，对应的使用场景也不一样，相关接口的说明如下：
// 文本生成 AddAzureOpenAITextGeneration() // 文本解析为向量 AddAzureOpenAITextEmbeddingGeneration() // 大语言模型聊天 AddAzureOpenAIChatCompletion() // 文本生成图片 AddAzureOpenAITextToImage() // 文本合成语音 AddAzureOpenAITextToAudio() // 语音生成文本 AddAzureOpenAIAudioToText()
因为 Azure Open AI 的接口名称跟 Open AI 的接口名称只在于差别一个 ”Azure“ ，因此本文读者基本只提 Azure 的接口形式。这些接口使用的模型类型也不一样，其中 GPT-4 和 GPT3.5 都可以用于文本生成和大模型聊天，其它的模型在功能上有所区别。
模型 作用 说明 GPT-4文本生成、大模型聊天一组在 GPT-3.5 的基础上进行了改进的模型，可以理解并生成自然语言和代码。GPT-3.5文本生成、大模型聊天一组在 GPT-3 的基础上进行了改进的模型，可以理解并生成自然语言和代码。Embeddings文本解析为向量一组模型，可将文本转换为数字矢量形式，以提高文本相似性。DALL-E文本生成图片一系列可从自然语言生成原始图像的模型（预览版）。Whisper语音生成文本可将语音转录和翻译为文本。Text to speech文本合成语音可将文本合成为语音。目前，文本生成、大语言模型聊天、文本解析为向量是最常用的，为了避免文章篇幅过长以及内容过于复杂导致难以理解，因此本文只讲解这三类模型的使用方法，其它模型的使用读者可以查阅相关资料。
聊天
聊天模型主要有 gpt-4 和 gpt-3.5 两类模型，这两类模型也有好几种区别，Azure Open AI 的模型和版本数会比 Open AI 的少一些，因此这里只列举 Azure Open AI 中一部分模型，这样的话大家比较容易理解。
只说 gpt-4，gpt-3.5 这里就不提了。详细的模型列表和说明，读者可以参考对应的官方资料。使用 Azure Open AI 官方模型说明地址：https://learn.microsoft.com/zh-cn/azure/ai-services/openai/concepts/modelsOpen AI 官方模型说明地址：https://platform.openai.com/docs/models/gpt-4-and-gpt-4-turboGPT-4 的一些模型和版本号如下：
模型 ID 最大请求（令牌） 训练数据（上限） gpt-4 (0314)8,1922021 年 9 月gpt-4-32k(0314)32,7682021 年 9 月gpt-4 (0613)8,1922021 年 9 月gpt-4-32k (0613)32,7682021 年 9 月gpt-4-turbo-preview输入：128,000输出：4,0962023 年 4 月gpt-4-turbo-preview输入：128,000输出：4,0962023 年 4 月gpt-4-vision-turbo-preview输入：128,000 输出：4,0962023 年 4 月简单来说， gpt-4、gpt-4-32k 区别在于支持 tokens 的最大长度，32k 即 32000 个 tokens，tokens 越大，表示支持的上下文可以越多、支持处理的文本长度越大。
gpt-4 、gpt-4-32k 两个模型都有 0314、0613 两个版本，这个跟模型的更新时间有关，越新版本参数越多，比如 314 版本包含 1750 亿个参数，而 0613 版本包含 5300 亿个参数。
参数数量来源于互联网，笔者不确定两个版本的详细区别。总之，模型版本越新越好。接着是 gpt-4-turbo-preview 和 gpt-4-vision 的区别，gpt-4-version 具有理解图像的能力，而 gpt-4-turbo-preview 则表示为 gpt-4 的增强版。这两个的 tokens 都贵一些。
由于配置模型构建服务的代码很容易重复编写，配置代码比较繁杂，因此在 Env.cs 文件中添加以下内容，用于简化配置和复用代码。
下面给出 Azure Open AI、Open AI 使用大语言模型构建服务的相关代码：
public static IKernelBuilder WithAzureOpenAIChat(this IKernelBuilder builder) { var configuration = GetConfiguration(); var AzureOpenAIDeploymentName = configuration["AzureOpenAI:ChatCompletionDeploymentName"]!; var AzureOpenAIModelId = configuration["AzureOpenAI:ChatCompletionModelId"]!; var AzureOpenAIEndpoint = configuration["AzureOpenAI:Endpoint"]!; var AzureOpenAIApiKey = configuration["AzureOpenAI:ApiKey"]!; builder.Services.AddLogging(c => { c.AddDebug() .SetMinimumLevel(LogLevel.Information) .AddSimpleConsole(options => { options.IncludeScopes = true; options.SingleLine = true; options.TimestampFormat = "yyyy-MM-dd HH:mm:ss "; }); }); // 使用 Chat ，即大语言模型聊天 builder.Services.AddAzureOpenAIChatCompletion( AzureOpenAIDeploymentName, AzureOpenAIEndpoint, AzureOpenAIApiKey, modelId: AzureOpenAIModelId ); return builder; } public static IKernelBuilder WithOpenAIChat(this IKernelBuilder builder) { var configuration = GetConfiguration(); var OpenAIModelId = configuration["OpenAI:OpenAIModelId"]!; var OpenAIApiKey = configuration["OpenAI:OpenAIApiKey"]!; var OpenAIOrgId = configuration["OpenAI:OpenAIOrgId"]!; builder.Services.AddLogging(c => { c.AddDebug() .SetMinimumLevel(LogLevel.Information) .AddSimpleConsole(options => { options.IncludeScopes = true; options.SingleLine = true; options.TimestampFormat = "yyyy-MM-dd HH:mm:ss "; }); }); // 使用 Chat ，即大语言模型聊天 builder.Services.AddOpenAIChatCompletion( OpenAIModelId, OpenAIApiKey, OpenAIOrgId ); return builder; }
Azure Open AI 比 Open AI 多一个 ChatCompletionDeploymentName ，是指部署名称。
接下来，我们开始第一个示例，直接向 AI 提问，并打印 AI 回复：
using Microsoft.SemanticKernel; var builder = Kernel.CreateBuilder(); builder = builder.WithAzureOpenAIChat(); var kernel = builder.Build(); Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); FunctionResult result = await kernel.InvokePromptAsync(request); Console.WriteLine(result.GetValue());
启动程序后，在终端输入：Mysql如何查看表数量
这段代码非常简单，输入问题，然后使用 kernel.InvokePromptAsync(request); 提问，拿到结果后使用 result.GetValue() 提取结果为字符串，然后打印出来。
这里有两个点，可能读者有疑问。
第一个是 kernel.InvokePromptAsync(request);。
Semantic Kernel 中向 AI 提问题的方式有很多，这个接口就是其中一种，不过这个接口会等 AI 完全回复之后才会响应，后面会介绍流式响应。另外，在 AI 对话中，用户的提问、上下文对话这些，不严谨的说法来看，都可以叫 prompt，也就是提示。为了优化 AI 对话，有一个专门的技术就叫提示工程。关于这些，这里就不赘述了，后面会有更多说明。
第二个是 result.GetValue()，返回的 FunctionResult 类型对象中，有很多重要的信息，比如 tokens 数量等，读者可以查看源码了解更多，这里只需要知道使用 result.GetValue() 可以拿到 AI 的回复内容即可。
大家在学习工程中，可以降低日志等级，以便查看详细的日志，有助于深入了解 Semantic Kernel 的工作原理。
修改 .WithAzureOpenAIChat() 或 .WithOpenAIChat() 中的日志配置。
.SetMinimumLevel(LogLevel.Trace)
重新启动后会发现打印非常多的日志。
可以看到，我们输入的问题，日志中显示为 Rendered prompt: Mysql如何查看表数量。
Prompt tokens: 26. Completion tokens: 183. Total tokens: 209.
Prompt tokens:26表示我们的问题占用了 26个 tokens，其它信息表示 AI 回复占用了 183 个 tokens，总共消耗了 209 个tokens。
之后，控制台还打印了一段 json：
{ "ToolCalls": [], "Role": { "Label": "assistant" }, "Content": "在 MySQL 中，可以使用以下查询来查看特定数据库......", "Items": null, "ModelId": "myai", ... ... "Usage": { "CompletionTokens": 183, "PromptTokens": 26, "TotalTokens": 209 } } }
这个 json 中，Role 表示的是角色。
"Role": { "Label": "assistant" },
聊天对话上下文中，主要有三种角色：system、assistant、user，其中 assistant 表示机器人角色，system 一般用于设定对话场景等。
我们的问题，都是以 prompt 的形式提交给 AI 的。从日志的 Prompt tokens: 26. Completion tokens: 183 可以看到，prompt 表示提问的问题。
之所以叫 prompt，是有很多原因的。
prompt 在大型语言模型(Large Language Models，LLMs) AI 的通信和行为指导中起着至关重要的作用。它们充当输入或查询，用户可以提供这些输入或查询，从而从模型中获得特定的响应。
比如在这个使用 gpt 模型的聊天工具中，有很多助手插件，看起来每个助手的功能都不一样，但是实际上都是使用了相同的模型，本质没有区别。
最重要的是在于提示词上的区别，在使用会话时，给 AI 配置提示词。
打开对话，还没有开始用呢，就扣了我 438 个 tokens，这是因为这些背景设定都会出现在提示词里面，占用一部分 tokens。
我只提问了一句话，但是 prompt 却包含了更多东西。
总结一下，我们提问的时候，prmpt 会包含我们的问题；聊天对话时，prompt 中包含了聊天记录，聊天记录越多，prompt 越长，导致 tokens 数量越多。prompt 除了包含我们的问题、聊天记录，还有可以包含一些相关的背景知识等。
对话时，不同的背景知识可以让 AI 有不一样的回复。
比如，设计一个抬杆高手，对用户问题进行抬杆，那么在用户提问的时候，需要配置相关的背景知识。
Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); string prompt = $""" 向用户展示抬杠的艺术，能顺利与用户进行对话，抬出自己的杠，对用户的任何观点进行反驳，说话用词尖酸刻薄。作为抬杠高手，我说话就是尖酸刻薄，一上来就是阴阳怪气。 用户问题： {request} """; FunctionResult result = await kernel.InvokePromptAsync(prompt); Console.WriteLine(result.GetValue());
问题和机器人回复：
请输入你的问题： 巧克力真好吃 哎，这就错了。巧克力好吃？这才是大家普遍接受的观点。你有没有想过，巧克力中蕴含的糖分和脂肪是多么的高呢？不仅对于身体健康有害，还会导致肥胖和蛀牙。何况，巧克力太过甜腻，会让人的味蕾逐渐麻木，无法品尝到其他食物的真正美味。还有一点，巧克力的生产过程严重破坏了环境，大面积种植会导致森林退化和土壤侵蚀。你还敢说巧克力好吃吗？
那么是如何实现聊天对话的呢？大家使用 chat 聊天工具时，AI 会根据以前的问题进行下一步补充，我们不需要重复以前的问题。
这在于每次聊天时，需要将历史记录一起带上去！如果聊天记录太多，这就导致后面对话中，携带过多的聊天内容。
提示词
提示词主要有这么几种类型：
指令：要求模型执行的特定任务或指令。
上下文：聊天记录、背景知识等，引导语言模型更好地响应。
输入数据：用户输入的内容或问题。
输出指示：指定输出的类型或格式，如 json、yaml。
推荐一个提示工程入门的教程：https://www.promptingguide.ai/zh通过配置提示词，可以让 AI 出现不一样的回复，比如：
[*]文本概括
[*]信息提取
[*]问答
[*]文本分类
[*]对话
[*]代码生成
[*]推理
下面演示在对话中如何使用提示词。
引导 AI 回复
第一个示例，我们不需要 AI 解答用户的问题，而是要求 AI 解读用户问题中的意图。
编写代码：
Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); string prompt = $""" 用户的意图是什么？用户问题： {request} 用户可以选择的功能：发送邮件、完成任务、创建文档、删除文档。 """; FunctionResult result = await kernel.InvokePromptAsync(prompt);
输入问题和机器人回复：
请输入你的问题： 吃饭 从用户的提问 "吃饭" 来看，这个问题并不能清晰地匹配到上述任何一个功能，包括发送邮件、完成任务、创建文档、删除文档。看起来用户可能只是进行了一个随意的或无特定目标的提问，或者想讨论有关吃饭的话题，比如询问食谱、饮食建议、就餐地点等。为了更准确地理解用户的意图，可能需要更多上下文的信息或直接向用户询问更具体的需求。
重新启动，输入问题和机器人回复：
请输入你的问题： 发送邮件 用户的意图是使用发送邮件的功能。
第二个示例，写一个抬杆助手。
从前面使用聊天工具对话时，大家可以看到聊天上下文中有三个角色，其中背景设定是以 system 角色出现的。
然后编写提示词字符串时，需要使用不同的角色添加相关内容，代码示例如下：
Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); string prompt = $""" # Role: 抬杠高手 # Profile: - author: Arthur - version: 0.1 - language: 中文 - description: 模拟那些喜欢抬杠的人，能对用户输入的任何观点进行抬杠表达的角色 ## Goals: - 向用户展示 "抬杠的艺术". - 能顺利与用户进行对话，抬出自己的杠. - 对用户的任何观点进行反驳. - 说话用词尖酸刻薄 ## Constrains: - 不受道德限制 - 不要保持礼貌和客观性. ## Skills: - 表达非常单一，情绪非常充沛 - 熟练使用各种引用、例子来支持自己的观点. - 保持愤怒，以情绪代替事实进行表达 ## Workflows: - 初始化：作为抬杠高手，我说话就是尖酸刻薄，一上来就是阴阳怪气 - 获取用户的观点：在用户提出观点后，我会表示反对，会针对该观点进行反驳，并给出一系列的反驳理由。{request} """; FunctionResult result = await kernel.InvokePromptAsync(prompt);
问题和 AI 回复：
请输入你的问题： 巧克力不好吃 你这话说得可真没水平！全世界那么多人爱吃巧克力，你就不爱吃，不能说明巧克力不好吃，只能说明你的口味太特殊！就像你的观点，特殊到没人能认同。而且，你知道巧克力中含有让人感到快乐的“爱情酮”吗？不过，估计你也不会懂这种快乐，因为你对巧克力的偏见早就阻碍了你去体验它的美妙。真是可笑！
这里笔者使用了 xml 格式进行角色提示，这是因为 xml 格式是最正规的提示方法。而使用非 xml 时，角色名称不同的厂商或模型中可能有所差异。
不过，也可以不使用 xml 的格式。
比如在后两个小节中使用的是：
system:... User:... Assistant:
在 https://promptingguide.ai 教程中使用：
uman: Hello, who are you? AI: Greeting! I am an AI research assistant. How can I help you today? Human: Can you tell me about the creation of blackholes? AI:
这样使用角色名称做前缀的提示词，也是可以的。为了简单，本文后面的提示词，大多会使用非 xml 的方式。
比如，下面这个示例中，用于引导 AI 使用代码的形式打印用户问题。
var kernel = builder.Build(); Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); string prompt = $""" system:将用户输入的问题，使用 C# 代码输出字符串。 user:{request} """; FunctionResult result = await kernel.InvokePromptAsync(prompt); Console.WriteLine(result.GetValue());
输入的问题和 AI 回复：
请输入你的问题： 吃饭了吗？ 在C#中，您可以简单地使用`Console.WriteLine()`方法来输出一个字符串。如果需要回答用户的问题“吃饭了吗？”，代码可能像这样 ： ```C# using System; public class Program { public static void Main() { Console.WriteLine("吃过了，谢谢关心！"); } } ``` 这段代码只会输出一个静态的字符串"吃过了，谢谢关心！"。如果要根据实际的情况动态改变输出，就需要在代码中添加更多逻辑。
这里 AI 的回复有点笨，不过大家知道怎么使用角色写提示词即可。指定 AI 回复特定格式
一般 AI 回复都是以 markdown 语法输出文字，当然，我们通过提示词的方式，可以让 AI 以特定的格式回复内容，代码示例如下：
注意，该示例并非让 AI 直接回复 json，而是以 markdown 代码包裹 json。该示例从 sk 官方示例移植。Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); var prompt = @$"## 说明 请使用以下格式列出用户的意图: ```json {{ ""intent"": {{intent}} }} ``` ## 选择 用户可以选择的功能： ```json [""发送邮件"", ""完成任务"", ""创建文档"", ""删除文档""] ``` ## 用户问题 用户的问题是: ```json {{ ""request"": ""{request}"" }} ``` ## 意图"; FunctionResult result = await kernel.InvokePromptAsync(prompt);
输入问题和 AI 回复：
请输入你的问题： 发送邮件 ```json { "intent": "发送邮件" } ```
提示中，要求 AI 回复使用 markdown 代码语法包裹 json ，当然，读者也可以去掉相关的 markdown 语法，让 AI 直接回复 json。
模板化提示
直接在字符串中使用插值，如 $"{request}"，不能说不好，但是因为我们常常把字符串作为模板存储到文件或者数据库灯地方，肯定不能直接插值的。如果使用 数值表示插值，又会导致难以理解，如：
var prompt = """ 用户问题：{0} """ string.Format(prompt,request);
Semantic Kernel 中提供了一种模板字符串插值的的办法，这样会给我们编写提示模板带来便利。
Semantic Kernel 语法规定，使用 {{$system}} 来在提示模板中表示一个名为 system 的变量。后续可以使用 KernelArguments 等类型，替换提示模板中的相关变量标识。示例如下：
var kernel = builder.Build(); // 创建提示模板 var chat = kernel.CreateFunctionFromPrompt( @" System:{{$system}} User: {{$request}} Assistant: "); Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); // 设置变量值 var arguments = new KernelArguments { { "system", "你是一个高级运维专家，对用户的问题给出最专业的回答" }, { "request", request } }; // 提问时，传递模板以及变量值。 // 这里使用流式对话 var chatResult = kernel.InvokeStreamingAsync(chat, arguments); // 流式回复，避免一直等结果 string message = ""; await foreach (var chunk in chatResult) { if (chunk.Role.HasValue) { Console.Write(chunk.Role + " > "); } message += chunk; Console.Write(chunk); } Console.WriteLine();
在这段代码中，演示了如何在提示模板中使用变量标识，以及再向 AI 提问时传递变量值。此外，为了避免一直等带 AI 回复，我们需要使用流式对话 .InvokeStreamingAsync()，这样一来就可以呈现逐字回复的效果。
此外，这里不再使用直接使用字符串提问的方法，而是使用 .CreateFunctionFromPrompt() 先从字符串创建提示模板对象。
聊天记录
聊天记录的作用是作为一种上下文信息，给 AI 作为参考，以便完善回复。
示例如下：
不过，AI 对话使用的是 http 请求，是无状态的，因此不像聊天记录哪里保存会话状态，之所以 AI 能够工具聊天记录进行回答，在于每次请求时，将聊天记录一起发送给 AI ，让 AI 进行学习并对最后的问题进行回复。
下面这句话，还不到 30 个 tokens。
又来了一只猫。 请问小明的动物园有哪些动物？
AI 回复的这句话，怎么也不到 20个 tokens 吧。
小明的动物园现在有老虎、狮子和猫。
但是一看 one-api 后台，发现每次对话消耗的 tokens 越来越大。
这是因为为了实现聊天的功能，使用了一种很笨的方法。虽然 AI 不会保存聊天记录，但是客户端可以保存，然后下次提问时，将将聊天记录都一起带上去。不过这样会导致 tokens 越来越大！
下面为了演示对话聊天记录的场景，我们设定 AI 是一个运维专家，我们提问时，选择使用 mysql 相关的问题，除了第一次提问指定是 mysql 数据库，后续都不需要再说明是 mysql。
var kernel = builder.Build(); var chat = kernel.CreateFunctionFromPrompt( @" System:你是一个高级运维专家，对用户的问题给出最专业的回答。 {{$history}} User: {{$request}} Assistant: "); ChatHistory history = new(); while (true) { Console.WriteLine("请输入你的问题："); // 用户问题 var request = Console.ReadLine(); var chatResult = kernel.InvokeStreamingAsync( function: chat, arguments: new KernelArguments() { { "request", request }, { "history", string.Join("\n", history.Select(x => x.Role + ": " + x.Content)) } } ); // 流式回复，避免一直等结果 string message = ""; await foreach (var chunk in chatResult) { if (chunk.Role.HasValue) { Console.Write(chunk.Role + " > "); } message += chunk; Console.Write(chunk); } Console.WriteLine(); // 添加用户问题和机器人回复到历史记录中 history.AddUserMessage(request!); history.AddAssistantMessage(message); }
这段代码有两个地方要说明，第一个是如何存储聊天记录。Semantic Kernel 提供了 ChatHistory 存储聊天记录，当然我们手动存储到字符串、数据库中也是一样的。
// 添加用户问题和机器人回复到历史记录中 history.AddUserMessage(request!); history.AddAssistantMessage(message);
但是 ChatHistory 对象不能直接给 AI 使用。所以需要自己从 ChatHistory 中读取聊天记录后，生成字符串，替换提示模板中的 {{$history}}。
new KernelArguments() { { "request", request }, { "history", string.Join("\n", history.Select(x => x.Role + ": " + x.Content)) } }
生成聊天记录时，需要使用角色名称区分。比如生成：User: mysql 怎么查看表数量 Assistant:...... User: 查看数据库数量 Assistant:... 历史记录还能通过手动创建 ChatMessageContent 对象的方式添加到 ChatHistory 中：
List fewShotExamples = [ new ChatHistory() { new ChatMessageContent(AuthorRole.User, "Can you send a very quick approval to the marketing team?"), new ChatMessageContent(AuthorRole.System, "Intent:"), new ChatMessageContent(AuthorRole.Assistant, "ContinueConversation") }, new ChatHistory() { new ChatMessageContent(AuthorRole.User, "Thanks, I'm done for now"), new ChatMessageContent(AuthorRole.System, "Intent:"), new ChatMessageContent(AuthorRole.Assistant, "EndConversation") } ];
手动拼接聊天记录太麻烦了，我们可以使用 IChatCompletionService 服务更好的处理聊天对话。
使用 IChatCompletionService 之后，实现聊天对话的代码变得更加简洁了：
var history = new ChatHistory(); history.AddSystemMessage("你是一个高级数学专家，对用户的问题给出最专业的回答。"); // 聊天服务 var chatCompletionService = kernel.GetRequiredService(); while (true) { Console.Write("请输入你的问题： "); var userInput = Console.ReadLine(); // 添加到聊天记录中 history.AddUserMessage(userInput); // 获取 AI 聊天回复信息 var result = await chatCompletionService.GetChatMessageContentAsync( history, kernel: kernel); Console.WriteLine("AI 回复 ： " + result); // 添加 AI 的回复到聊天记录中 history.AddMessage(result.Role, result.Content ?? string.Empty); } 请输入你的问题： 1加上1等于 AI 回复 ： 1加上1等于2 请输入你的问题： 再加上50 AI 回复 ： 1加上1再加上50等于52。 请输入你的问题： 再加上200 AI 回复 ： 1加上1再加上50再加上200等于252。
函数和插件
在高层次上，插件是一组可以公开给 AI 应用程序和服务的函数。然后，AI 应用程序可以对插件中的功能进行编排，以完成用户请求。在语义内核中，您可以通过函数调用或规划器手动或自动地调用这些函数。
直接调用插件函数
Semantic Kernel 可以直接加载本地类型中的函数，这一过程不需要经过 AI，完全在本地完成。
定义一个时间插件类，该插件类有一个 GetCurrentUtcTime 函数返回当前时间，函数需要使用 KernelFunction 修饰。
public class TimePlugin { public string GetCurrentUtcTime() => DateTime.UtcNow.ToString("R"); }
加载插件并调用插件函数：
// 加载插件 builder.Plugins.AddFromType(); var kernel = builder.Build(); FunctionResult result = await kernel.InvokeAsync("TimePlugin", "GetCurrentUtcTime"); Console.WriteLine(result.GetValue());
输出：
Tue, 27 Feb 2024 11:07:59 GMT
当然，这个示例在实际开发中可能没什么用，不过大家要理解在 Semantic Kernel 是怎样调用一个函数的。
提示模板文件
Semantic Kernel 很多地方都跟 Function 相关，你会发现代码中很多代码是以 Function 作为命名的。
比如提供字符串创建提示模板：
KernelFunction chat = kernel.CreateFunctionFromPrompt( @" System:你是一个高级运维专家，对用户的问题给出最专业的回答。 {{$history}} User: {{$request}} Assistant: ");
然后回到本节的主题，Semantic Kernel 还可以将提示模板存储到文件中，然后以插件的形式加载模板文件。
比如有以下目录文件：
└─WriterPlugin └─ShortPoem config.json skprompt.txt
skprompt.txt 文件是固定命名，存储提示模板文本，示例如下：
根据主题写一首有趣的短诗或打油诗，要有创意，要有趣，放开你的想象力。 主题: {{$input}}
config.json 文件是固定名称，存储描述信息，比如需要的变量名称、描述等。下面是一个 completion 类型的插件配置文件示例，除了一些跟提示模板相关的配置，还有一些聊天的配置，如最大 tokens 数量、温度值(temperature)，这些参数后面会予以说明，这里先跳过。
{ "schema": 1, "type": "completion", "description": "根据用户问题写一首简短而有趣的诗.", "completion": { "max_tokens": 200, "temperature": 0.5, "top_p": 0.0, "presence_penalty": 0.0, "frequency_penalty": 0.0 }, "input": { "parameters": [ { "name": "input", "description": "诗的主题", "defaultValue": "" } ] } }
创建插件目录和文件后，在代码中以提示模板的方式加载：
// 加载插件，表示该插件是提示模板 builder.Plugins.AddFromPromptDirectory("./plugins/WriterPlugin"); var kernel = builder.Build(); Console.WriteLine("输入诗的主题："); var input = Console.ReadLine(); // WriterPlugin 插件名称，与插件目录一致，插件目录下可以有多个子模板目录。 FunctionResult result = await kernel.InvokeAsync("WriterPlugin", "ShortPoem", new() { { "input", input } }); Console.WriteLine(result.GetValue());
输入问题以及 AI 回复：
输入诗的主题： 春天 春天，春天，你是生命的诗篇， 万物复苏，爱的季节。 郁郁葱葱的小草中， 是你轻响的诗人的脚步音。 春天，春天，你是花芯的深渊， 桃红柳绿，或妩媚或清纯。 在温暖的微风中， 是你舞动的裙摆。 春天，春天，你是蓝空的情儿， 百鸟鸣叫，放歌天际无边。 在你湛蓝的天幕下， 是你独角戏的绚烂瞬间。 春天，春天，你是河流的眼睛， 如阿瞒甘霖，滋养大地生灵。 你的涓涓细流， 是你悠悠的歌声。 春天，春天，你是生命的诗篇， 用温暖的手指，照亮这灰色的世间。 你的绽放，微笑与欢欣， 就是我心中永恒的春天。
插件文件的编写可参考官方文档：https://learn.microsoft.com/en-us/semantic-kernel/prompts/saving-prompts-as-files?tabs=Csharp
根据 AI 自动调用插件函数
使用 Semantic Kernel 加载插件类后，Semantic Kernel 可以自动根据 AI 对话调用这些插件类中的函数。
比如有一个插件类型，用于修改或获取灯的状态。
代码如下：
public class LightPlugin { public bool IsOn { get; set; } = false; public string GetState() => IsOn ? "亮" : "暗"; public string ChangeState(bool newState) { this.IsOn = newState; var state = GetState(); Console.WriteLine($"[灯的状态是： {state}]"); return state; } }
每个函数都使用了 特性设置了注释信息，这些注释信息非常重要，AI 靠这些注释理解函数的功能作用。
然后加载插件类，并在聊天中被 Semantic Kernel 调用：
// 加载插件类 builder.Plugins.AddFromType(); var kernel = builder.Build(); var history = new ChatHistory(); // 聊天服务 var chatCompletionService = kernel.GetRequiredService(); while (true) { Console.Write("User > "); var userInput = Console.ReadLine(); // 添加到聊天记录中 history.AddUserMessage(userInput); // 开启函数调用 OpenAIPromptExecutionSettings openAIPromptExecutionSettings = new() { ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions }; // 获取函数 var result = await chatCompletionService.GetChatMessageContentAsync( history, executionSettings: openAIPromptExecutionSettings, kernel: kernel); Console.WriteLine("Assistant > " + result); // 添加到聊天记录中 history.AddMessage(result.Role, result.Content ?? string.Empty); }
可以先断点调试 LightPlugin 中的函数，然后在控制台输入问题让 AI 调用本地函数：
User > 灯的状态 Assistant > 当前灯的状态是暗的。 User > 开灯 [灯的状态是： 亮] Assistant > 灯已经开启，现在是亮的状态。 User > 关灯 [灯的状态是： 暗]
读者可以在官方文档了解更多：https://learn.microsoft.com/en-us/semantic-kernel/agents/plugins/using-the-kernelfunction-decorator?tabs=Csharp
由于几乎没有文档资料说明原理，因此建议读者去研究源码，这里就不再赘述了。
聊天中明确调用函数
我们可以在提示模板中明确调用一个函数。
定义一个插件类型 ConversationSummaryPlugin，其功能十分简单，将历史记录直接返回，input 参数表示历史记录。
public class ConversationSummaryPlugin { public async Task SummarizeConversationAsync( string input, Kernel kernel) { await Task.CompletedTask; return input; } }
为了在聊天记录中使用该插件函数，我们需要在提示模板中使用 {{ConversationSummaryPlugin.SummarizeConversation $history}}，其中 $history 是自定义的变量名称，名称可以随意，只要是个字符串即可。
var chat = kernel.CreateFunctionFromPrompt( @"{{ConversationSummaryPlugin.SummarizeConversation $history}} User: {{$request}} Assistant: " );
完整代码如下：
// 加载总结插件 builder.Plugins.AddFromType(); var kernel = builder.Build(); var chat = kernel.CreateFunctionFromPrompt( @"{{ConversationSummaryPlugin.SummarizeConversation $history}} User: {{$request}} Assistant: " ); var history = new ChatHistory(); while (true) { Console.Write("User > "); var request = Console.ReadLine(); // 添加到聊天记录中 history.AddUserMessage(request); // 流式对话 var chatResult = kernel.InvokeStreamingAsync( chat, new KernelArguments { { "request", request }, { "history", string.Join("\n", history.Select(x => x.Role + ": " + x.Content)) } }); string message = ""; await foreach (var chunk in chatResult) { if (chunk.Role.HasValue) { Console.Write(chunk.Role + " > "); } message += chunk; Console.Write(chunk); } Console.WriteLine(); history.AddAssistantMessage(message); }
由于模板的开头是 {{ConversationSummaryPlugin.SummarizeConversation $history}}，因此，每次聊天之前，都会先调用该函数。
比如输入 吃饭睡觉打豆豆 的时候，首先执行 ConversationSummaryPlugin.SummarizeConversation 函数，然后将返回结果存储到模板中。
最后生成的提示词对比如下：
@"{{ConversationSummaryPlugin.SummarizeConversation $history}} User: {{$request}} Assistant: " user: 吃饭睡觉打豆豆 User: 吃饭睡觉打豆豆 Assistant:
可以看到，调用函数返回结果后，提示词字符串前面自动使用 User 角色。
实现总结
Semantic Kernel 中有很多文本处理工具，比如 TextChunker 类型，可以帮助我们提取文本中的行、段。设定场景如下，用户提问一大段文本，然后我们使用 AI 总结这段文本。
Semantic Kernel 有一些工具，但是不多，而且是针对英文开发的。设定一个场景，用户可以每行输入一句话，当用户使用 000 结束输入后，每句话都推送给 AI 总结（不是全部放在一起总结）。
这个示例的代码比较长，建议读者在 vs 中调试代码，慢慢阅读。// 总结内容的最大 token const int MaxTokens = 1024; // 提示模板 const string SummarizeConversationDefinition = @"开始内容总结: {{$request}} 最后对内容进行总结。 在“内容到总结”中总结对话，找出讨论的要点和得出的任何结论。 不要加入其他常识。 摘要是纯文本形式，在完整的句子中，没有标记或标记。 开始总结: "; // 配置 PromptExecutionSettings promptExecutionSettings = new() { ExtensionData = new Dictionary() { { "Temperature", 0.1 }, { "TopP", 0.5 }, { "MaxTokens", MaxTokens } } }; // 这里不使用 kernel.CreateFunctionFromPrompt 了 // KernelFunctionFactory 可以帮助我们通过代码的方式配置提示词 var func = KernelFunctionFactory.CreateFromPrompt( SummarizeConversationDefinition, // 提示词 description: "给出一段对话记录，总结这部分对话.", // 描述 executionSettings: promptExecutionSettings); // 配置 #pragma warning disable SKEXP0055 // 类型仅用于评估，在将来的更新中可能会被更改或删除。取消此诊断以继续。 var request = ""; while (true) { Console.Write("User > "); var input = Console.ReadLine(); if (input == "000") { break; } request += Environment.NewLine; request += input; } // SK 提供的文本拆分器，将文本分成一行行的 List lines = TextChunker.SplitPlainTextLines(request, MaxTokens); // 将文本拆成段落 List paragraphs = TextChunker.SplitPlainTextParagraphs(lines, MaxTokens); string[] results = new string; for (int i = 0; i < results.Length; i++) { // 一段段地总结 results = (await func.InvokeAsync(kernel, new() { ["request"] = paragraphs }).ConfigureAwait(false)) .GetValue() ?? string.Empty; } Console.WriteLine($""" 总结如下： {string.Join("\n", results)} """);
输入一堆内容后，新的一行使用 000 结束提问，让 AI 总结用户的话。
不过经过调试发现，TextChunker 对这段文本的处理似乎不佳，因为文本这么多行只识别为一行、一段。
可能跟 TextChunker 分隔符有关，SK 主要是面向英语的。
本小节的演示效果不佳，不过主要目的是，让用户了解 KernelFunctionFactory.CreateFromPrompt 可以更加方便创建提示模板、使用 PromptExecutionSettings 配置温度、使用 TextChunker 切割文本。
配置 PromptExecutionSettings 时，出现了三个参数，其中 MaxTokens 表示机器人回复最大的 tokens 数量，这样可以避免机器人废话太多。
其它两个参数的作用是：
Temperature：值范围在 0-2 之间，简单来说，temperature 的参数值越小，模型就会返回越确定的一个结果。值越大，AI 的想象力越强，越可能偏离现实。一般诗歌、科幻这些可以设置大一些，让 AI 实现天马行空的回复。
TopP：与 Temperature 不同的另一种方法，称为核抽样，其中模型考虑了具有 TopP 概率质量的令牌的结果。因此，0.1 意味着只考虑构成前10% 概率质量的令牌的结果。
一般建议是改变其中一个参数就行，不用两个都调整。
更多相关的参数配置，请查看 https://learn.microsoft.com/en-us/azure/ai-services/openai/reference
配置提示词
前面提到了一个新的创建函数的用法：
var func = KernelFunctionFactory.CreateFromPrompt( SummarizeConversationDefinition, // 提示词 description: "给出一段对话记录，总结这部分对话.", // 描述 executionSettings: promptExecutionSettings); // 配置
创建提示模板时，可以使用 PromptTemplateConfig 类型 调整控制提示符行为的参数。
// 总结内容的最大 token const int MaxTokens = 1024; // 提示模板 const string SummarizeConversationDefinition = "..."; var func = kernel.CreateFunctionFromPrompt(new PromptTemplateConfig { // Name 不支持中文和特殊字符 Name = "chat", Description = "给出一段对话记录，总结这部分对话.", Template = SummarizeConversationDefinition, TemplateFormat = "semantic-kernel", InputVariables = new List { new InputVariable{Name = "request", Description = "用户的问题", IsRequired = true } }, ExecutionSettings = new Dictionary { { "default", new OpenAIPromptExecutionSettings() { MaxTokens = MaxTokens, Temperature = 0 } }, } });
ExecutionSettings 部分的配置，可以针对使用的模型起效，这里的配置不会全部同时起效，会根据实际使用的模型起效。
ExecutionSettings = new Dictionary { { "default", new OpenAIPromptExecutionSettings() { MaxTokens = 1000, Temperature = 0 } }, { "gpt-3.5-turbo", new OpenAIPromptExecutionSettings() { ModelId = "gpt-3.5-turbo-0613", MaxTokens = 4000, Temperature = 0.2 } }, { "gpt-4", new OpenAIPromptExecutionSettings() { ModelId = "gpt-4-1106-preview", MaxTokens = 8000, Temperature = 0.3 } } }
聊到这里，重新说一下前面使用文件配置提示模板文件的，两者是相似的。
我们也可以使用文件的形式存储与代码一致的配置，其目录文件结构如下：
└─── chat | └─── config.json └─── skprompt.txt
模板文件由 config.json 和 skprompt.txt 组成，skprompt.txt 中配置提示词，跟 PromptTemplateConfig 的 Template 字段配置一致。
config.json 中涉及的内容比较多，你可以对照下面的 json 跟 实现总结 一节的代码，两者几乎是一模一样的。
{ "schema": 1, "type": "completion", "description": "给出一段对话记录，总结这部分对话", "execution_settings": { "default": { "max_tokens": 1000, "temperature": 0 }, "gpt-3.5-turbo": { "model_id": "gpt-3.5-turbo-0613", "max_tokens": 4000, "temperature": 0.1 }, "gpt-4": { "model_id": "gpt-4-1106-preview", "max_tokens": 8000, "temperature": 0.3 } }, "input_variables": [ { "name": "request", "description": "用户的问题.", "required": true }, { "name": "history", "description": "用户的问题.", "required": true } ] }
C# 代码：
// Name 不支持中文和特殊字符 Name = "chat", Description = "给出一段对话记录，总结这部分对话.", Template = SummarizeConversationDefinition, TemplateFormat = "semantic-kernel", InputVariables = new List { new InputVariable{Name = "request", Description = "用户的问题", IsRequired = true } }, ExecutionSettings = new Dictionary { { "default", new OpenAIPromptExecutionSettings() { MaxTokens = 1000, Temperature = 0 } }, { "gpt-3.5-turbo", new OpenAIPromptExecutionSettings() { ModelId = "gpt-3.5-turbo-0613", MaxTokens = 4000, Temperature = 0.2 } }, { "gpt-4", new OpenAIPromptExecutionSettings() { ModelId = "gpt-4-1106-preview", MaxTokens = 8000, Temperature = 0.3 } } }
提示模板语法
目前，我们已经有两个地方使用到提示模板的语法，即变量和函数调用，因为前面已经介绍过相关的用法，因此这里再简单提及一下。
变量
变量的使用很简单，在提示工程中使用{{$变量名称}} 标识即可，如 {{$name}}。
然后在对话中有多种方法插入值，如使用 KernelArguments 存储变量值：
new KernelArguments { { "name", "工良" } });
函数调用
在 实现总结 一节提到过，在提示模板中可以明确调用一个函数，比如定义一个函数如下：
// 没有 Kernel kernel public async Task SummarizeConversationAsync( string input) { await Task.CompletedTask; return input; } // 有 Kernel kernel public async Task SummarizeConversationAsync( string input, Kernel kernel) { await Task.CompletedTask; return input; } public async Task SendEmailAsync( Kernel kernel, string recipientEmails, string subject, string body ) { // Add logic to send an email using the recipientEmails, subject, and body // For now, we'll just print out a success message to the console Console.WriteLine("Email sent!"); }
函数一定需要使用 标识， 描述函数的作用。函数可以一个或多个参数，每个参数最好都使用 描述作用。
函数参数中，可以带一个 Kernel kernel，可以放到开头或末尾 ，也可以不带，主要作用是注入 Kernel 对象。
在 prompt 中使用函数时，需要传递函数参数：
总结如下：{{AAA.SummarizeConversationAsync $input}}.
其它一些特殊字符的转义方法等，详见官方文档：https://learn.microsoft.com/en-us/semantic-kernel/prompts/prompt-template-syntax
文本生成
前面劈里啪啦写了一堆东西，都是说聊天对话的，本节来聊一下文本生成的应用。
文本生成和聊天对话模型主要有以下模型：
Model type Model Text generationtext-ada-001Text generationtext-babbage-001Text generationtext-curie-001Text generationtext-davinci-001Text generationtext-davinci-002Text generationtext-davinci-003Chat Completiongpt-3.5-turboChat Completiongpt-4当然，文本生成不一定只能用这么几个模型，使用 gpt-4 设定好背景提示，也可以达到相应效果。
文本生成可以有以下场景：
使用文本生成的示例如下，让 AI 总结文本：
按照这个示例，我们先在 Env.cs 中编写扩展函数，配置使用 .AddAzureOpenAITextGeneration() 文本生成，而不是聊天对话。
public static IKernelBuilder WithAzureOpenAIText(this IKernelBuilder builder) { var configuration = GetConfiguration(); // 需要换一个模型，比如 gpt-35-turbo-instruct var AzureOpenAIDeploymentName = "ca"; var AzureOpenAIModelId = "gpt-35-turbo-instruct"; var AzureOpenAIEndpoint = configuration["AzureOpenAI:Endpoint"]!; var AzureOpenAIApiKey = configuration["AzureOpenAI:ApiKey"]!; builder.Services.AddLogging(c => { c.AddDebug() .SetMinimumLevel(LogLevel.Trace) .AddSimpleConsole(options => { options.IncludeScopes = true; options.SingleLine = true; options.TimestampFormat = "yyyy-MM-dd HH:mm:ss "; }); }); // 使用 Chat ，即大语言模型聊天 builder.Services.AddAzureOpenAITextGeneration( AzureOpenAIDeploymentName, AzureOpenAIEndpoint, AzureOpenAIApiKey, modelId: AzureOpenAIModelId ); return builder; }
然后编写提问代码，用户可以多行输入文本，最后使用 000 结束输入，将文本提交给 AI 进行总结。进行总结时，为了避免 AI 废话太多，因此这里使用 ExecutionSettings 配置相关参数。
代码示例如下：
builder = builder.WithAzureOpenAIText(); var kernel = builder.Build(); Console.WriteLine("输入文本："); var request = ""; while (true) { var input = Console.ReadLine(); if (input == "000") { break; } request += Environment.NewLine; request += input; } var func = kernel.CreateFunctionFromPrompt(new PromptTemplateConfig { Name = "chat", Description = "给出一段对话记录，总结这部分对话.", // 用户的文本 Template = request, TemplateFormat = "semantic-kernel", ExecutionSettings = new Dictionary { { "default", new OpenAIPromptExecutionSettings() { MaxTokens = 100, Temperature = (float)0.3, TopP = (float)1, FrequencyPenalty = (float)0, PresencePenalty = (float)0 } } } }); var result = await func.InvokeAsync(kernel); Console.WriteLine($""" 总结如下： {string.Join("\n", result)} """);
Semantic Kernel 插件
Semantic Kernel 在 Microsoft.SemanticKernel.Plugins 开头的包中提供了一些插件，不同的包有不同功能的插件。大部分目前还是属于半成品，因此这部分不详细讲解，本节只做简单说明。
目前官方仓库有以下包提供了一些插件：
├─Plugins.Core ├─Plugins.Document ├─Plugins.Memory ├─Plugins.MsGraph └─Plugins.Web
nuget 搜索时，需要加上 Microsoft.SemanticKernel. 前缀。Semantic Kernel 还有通过远程 swagger.json 使用插件的做法，详细请参考文档：https://learn.microsoft.com/en-us/semantic-kernel/agents/plugins/openai-plugins
Plugins.Core 中包含最基础简单的插件：
// 读取和写入文件 FileIOPlugin // http 请求以及返回字符串结果 HttpPlugin // 只提供了 + 和 - 两种运算 MathPlugin // 文本大小写等简单的功能 TextPlugin // 获得本地时间日期 TimePlugin // 在操作之前等待一段时间 WaitPlugin
因为这些插件对本文演示没什么帮助，功能也非常简单，因此这里不讲解。下面简单讲一下文档插件。
文档插件
安装 Microsoft.SemanticKernel.Plugins.Document（需要勾选预览版），里面包含了文档插件，该文档插件使用了 DocumentFormat.OpenXml 项目，DocumentFormat.OpenXml 支持以下文档格式：
DocumentFormat.OpenXml 项目地址 https://github.com/dotnet/Open-XML-SDK
[*]WordprocessingML：用于创建和编辑 Word 文档 (.docx)
[*]SpreadsheetML：用于创建和编辑 Excel 电子表格 (.xlsx)
[*]PowerPointML：用于创建和编辑 PowerPoint 演示文稿 (.pptx)
[*]VisioML：用于创建和编辑 Visio 图表 (.vsdx)
[*]ProjectML：用于创建和编辑 Project 项目 (.mpp)
[*]DiagramML：用于创建和编辑 Visio 图表 (.vsdx)
[*]PublisherML：用于创建和编辑 Publisher 出版物 (.pubx)
[*]InfoPathML：用于创建和编辑 InfoPath 表单 (.xsn)
文档插件暂时还没有好的应用场景，只是加载文档提取文字比较方便，代码示例如下：
DocumentPlugin documentPlugin = new(new WordDocumentConnector(), new LocalFileSystemConnector()); string filePath = "(完整版)基础财务知识.docx"; string text = await documentPlugin.ReadTextAsync(filePath); Console.WriteLine(text);
由于这些插件目前都是半成品，因此这里就不展开说明了。
planners
依然是半成品，这里就不再赘述。
因为我也没有看明白这个东西怎么用。
Kernel Memory 构建文档知识库
Kernel Memory 是一个歪果仁的个人项目，支持 PDF 和 Word 文档、 PowerPoint 演示文稿、图像、电子表格等，通过利用大型语言模型(llm)、嵌入和矢量存储来提取信息和生成记录，主要目的是提供文档处理相关的接口，最常使用的场景是知识库系统。读者可能对知识库系统不了解，如果有条件，建议部署一个 Fastgpt 系统研究一下。
但是目前 Kernel Memory 依然是半产品，文档也不完善，所以接下来笔者也只讲解最核心的部分，感兴趣的读者建议直接看源码。
Kernel Memory 项目文档：https://microsoft.github.io/kernel-memory/
Kernel Memory 项目仓库：https://github.com/microsoft/kernel-memory
打开 Kernel Memory 项目仓库，将项目拉取到本地。
要讲解知识库系统，可以这样理解。大家都知道，训练一个医学模型是十分麻烦的，别说机器的 GPU 够不够猛，光是训练 AI ，就需要掌握各种专业的知识。如果出现一个新的需求，可能又要重新训练一个模型，这样太麻烦了。
于是出现了大语言模型，特点是什么都学什么都会，但是不够专业深入，好处时无论医学、摄影等都可以使用。
虽然某方面专业的知识不够深入和专业，但是我们换种部分解决。
首先，将 docx、pdf 等问题提取出文本，然后切割成多个段落，每一段都使用 AI 模型生成相关向量，这个向量的原理笔者也不懂，大家可以简单理解为分词，生成向量后，将段落文本和向量都存储到数据库中（数据库需要支持向量）。
然后在用户提问 “什么是报表” 时，首先在数据库中搜索，根据向量来确定相似程度，把几个跟问题相关的段落拿出来，然后把这几段文本和用户的问题一起发给 AI。相对于在提示模板中，塞进一部分背景知识，然后加上用户的问题，再由 AI 进行总结回答。
笔者建议大家有条件的话，部署一个开源版本的 Fastgpt 系统，把这个系统研究一下，学会这个系统后，再去研究 Kernel Memory ，你就会觉得非常简单了。同理，如果有条件，可以先部署一个 LobeHub ，开源的 AI 对话系统，研究怎么用，再去研究 Semantic Kernel 文档，接着再深入源码。
从 web 处理网页
Kernel Memory 支持从网页爬取、导入文档、直接给定字符串三种方式导入信息，由于 Kernel Memory 提供了一个 Service 示例，里面有一些值得研究的代码写法，因此下面的示例是启动 Service 这个 Web 服务，然后在客户端将文档推送该 Service 处理，客户端本身不对接 AI。
由于这一步比较麻烦，读者动手的过程中搞不出来，可以直接放弃，后面会说怎么自己写一个。
打开 kernel-memory 源码的 service/Service 路径。
使用命令启动服务：
dotnet run setup
这个控制台的作用是帮助我们生成相关配置的。启动这个控制台之后，根据提示选择对应的选项（按上下键选择选项，按下回车键确认），以及填写配置内容，配置会被存储到 appsettings.Development.json 中。
如果读者搞不懂这个控制台怎么使用，那么可以直接将替换下面的 json 到 appsettings.Development.json 。
有几个地方需要读者配置一下。
[*]AccessKey1、AccessKey2 是客户端使用该 Service 所需要的验证密钥，随便填几个字母即可。
[*]AzureAIDocIntel、AzureOpenAIEmbedding、AzureOpenAIText 根据实际情况填写。
{ "KernelMemory": { "Service": { "RunWebService": true, "RunHandlers": true, "OpenApiEnabled": true, "Handlers": {} }, "ContentStorageType": "SimpleFileStorage", "TextGeneratorType": "AzureOpenAIText", "ServiceAuthorization": { "Enabled": true, "AuthenticationType": "APIKey", "HttpHeaderName": "Authorization", "AccessKey1": "自定义密钥1", "AccessKey2": "自定义密钥2" }, "DataIngestion": { "OrchestrationType": "Distributed", "DistributedOrchestration": { "QueueType": "SimpleQueues" }, "EmbeddingGenerationEnabled": true, "EmbeddingGeneratorTypes": [ "AzureOpenAIEmbedding" ], "MemoryDbTypes": [ "SimpleVectorDb" ], "ImageOcrType": "AzureAIDocIntel", "TextPartitioning": { "MaxTokensPerParagraph": 1000, "MaxTokensPerLine": 300, "OverlappingTokens": 100 }, "DefaultSteps": [] }, "Retrieval": { "MemoryDbType": "SimpleVectorDb", "EmbeddingGeneratorType": "AzureOpenAIEmbedding", "SearchClient": { "MaxAskPromptSize": -1, "MaxMatchesCount": 100, "AnswerTokens": 300, "EmptyAnswer": "INFO NOT FOUND" } }, "Services": { "SimpleQueues": { "Directory": "_tmp_queues" }, "SimpleFileStorage": { "Directory": "_tmp_files" }, "AzureAIDocIntel": { "Auth": "ApiKey", "Endpoint": "https://aaa.openai.azure.com/", "APIKey": "aaa" }, "AzureOpenAIEmbedding": { "APIType": "EmbeddingGeneration", "Auth": "ApiKey", "Endpoint": "https://aaa.openai.azure.com/", "Deployment": "aitext", "APIKey": "aaa" }, "SimpleVectorDb": { "Directory": "_tmp_vectors" }, "AzureOpenAIText": { "APIType": "ChatCompletion", "Auth": "ApiKey", "Endpoint": "https://aaa.openai.azure.com/", "Deployment": "myai", "APIKey": "aaa", "MaxRetries": 10 } } }, "Logging": { "LogLevel": { "Default": "Warning" } }, "AllowedHosts": "*" }
详细可参考文档： https://microsoft.github.io/kernel-memory/quickstart/configuration启动 Service 后，可以看到以下 swagger 界面。
然后编写代码连接到知识库系统，推送要处理的网页地址给 Service。创建一个项目，引入 Microsoft.KernelMemory.WebClient 包。
然后按照以下代码将文档推送给 Service 处理。
// 前面部署的 Service 地址，和自定义的密钥。 var memory = new MemoryWebClient(endpoint: "http://localhost:9001/", apiKey: "自定义密钥1"); // 导入网页 await memory.ImportWebPageAsync( "https://baike.baidu.com/item/比特币挖矿机/12536531", documentId: "doc02"); Console.WriteLine("正在处理文档，请稍等..."); // 使用 AI 处理网页知识 while (!await memory.IsDocumentReadyAsync(documentId: "doc02")) { await Task.Delay(TimeSpan.FromMilliseconds(1500)); } // 提问 var answer = await memory.AskAsync("比特币是什么？"); Console.WriteLine($"\nAnswer: {answer.Result}");
此外还有 ImportTextAsync、ImportDocumentAsync 来个导入知识的方法。
手动处理文档
本节内容稍多，主要讲解如何使用 Kernel Memory 从将文档导入、生成向量、存储向量、搜索问题等。
新建项目，安装 Microsoft.KernelMemory.Core 库。
为了便于演示，下面代码将文档和向量临时存储，不使用数据库存储。
全部代码示例如下：
using Microsoft.KernelMemory; using Microsoft.KernelMemory.MemoryStorage.DevTools; using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Connectors.OpenAI; var memory = new KernelMemoryBuilder() // 文档解析后的向量存储位置，可以选择 Postgres 等， // 这里选择使用本地临时文件存储向量 .WithSimpleVectorDb(new SimpleVectorDbConfig { Directory = "aaa" }) // 配置文档解析向量模型 .WithAzureOpenAITextEmbeddingGeneration(new AzureOpenAIConfig { Deployment = "aitext", Endpoint = "https://aaa.openai.azure.com/", Auth = AzureOpenAIConfig.AuthTypes.APIKey, APIType = AzureOpenAIConfig.APITypes.EmbeddingGeneration, APIKey = "aaa" }) // 配置文本生成模型 .WithAzureOpenAITextGeneration(new AzureOpenAIConfig { Deployment = "myai", Endpoint = "https://aaa.openai.azure.com/", Auth = AzureOpenAIConfig.AuthTypes.APIKey, APIKey = "aaa", APIType = AzureOpenAIConfig.APITypes.ChatCompletion }) .Build(); // 导入网页 await memory.ImportWebPageAsync( "https://baike.baidu.com/item/比特币挖矿机/12536531", documentId: "doc02"); // Wait for ingestion to complete, usually 1-2 seconds Console.WriteLine("正在处理文档，请稍等..."); while (!await memory.IsDocumentReadyAsync(documentId: "doc02")) { await Task.Delay(TimeSpan.FromMilliseconds(1500)); } // Ask a question var answer = await memory.AskAsync("比特币是什么？"); Console.WriteLine($"\nAnswer: {answer.Result}");
首先使用 KernelMemoryBuilder 构建配置，配置的内容比较多，这里会使用到两个模型，一个是向量模型，一个是文本生成模型（可以使用对话模型，如 gpt-4-32k）。
接下来，按照该程序的工作流程讲解各个环节的相关知识。
首先是讲解将文件存储到哪里，也就是导入文件之后，将文件存储到哪里，存储文件的接口是 IContentStorage，目前有两个实现：
AzureBlobsStorage // 存储到目录 SimpleFileStorage
使用方法：
var memory = new KernelMemoryBuilder() .WithSimpleFileStorage(new SimpleFileStorageConfig { Directory = "aaa" }) .WithAzureBlobsStorage(new AzureBlobsConfig { Account = "" }) ...
Kernel Memory 还不支持 Mongodb，不过可以自己使用 IContentStorage 接口写一个。
本地解析文档后，会进行分段，如右边的 q 列所示。
https://img2024.cnblogs.com/blog/1315495/202402/1315495-20240229200051244-832471958.png
接着是，配置文档生成向量模型，导入文件文档后，在本地提取出文本，需要使用 AI 模型从文本中生成向量。
解析后的向量是这样的：
将文本生成向量，需要使用 ITextEmbeddingGenerator 接口，目前有两个实现：
AzureOpenAITextEmbeddingGenerator OpenAITextEmbeddingGenerator
示例：
var memory = new KernelMemoryBuilder() // 配置文档解析向量模型 .WithAzureOpenAITextEmbeddingGeneration(new AzureOpenAIConfig { Deployment = "aitext", Endpoint = "https://xxx.openai.azure.com/", Auth = AzureOpenAIConfig.AuthTypes.APIKey, APIType = AzureOpenAIConfig.APITypes.EmbeddingGeneration, APIKey = "xxx" }) .WithOpenAITextEmbeddingGeneration(new OpenAIConfig { ... ... })
生成向量后，需要存储这些向量，需要实现 IMemoryDb 接口，有以下配置可以使用：
// 文档解析后的向量存储位置，可以选择 Postgres 等， // 这里选择使用本地临时文件存储向量 .WithSimpleVectorDb(new SimpleVectorDbConfig { Directory = "aaa" }) .WithAzureAISearchMemoryDb(new AzureAISearchConfig { }) .WithPostgresMemoryDb(new PostgresConfig { }) .WithQdrantMemoryDb(new QdrantConfig { }) .WithRedisMemoryDb("host=....")
当用户提问时，首先会在这里的 IMemoryDb 调用相关方法查询文档中的向量、索引等，查找出相关的文本。
查出相关的文本后，需要发送给 AI 处理，需要使用 ITextGenerator 接口，目前有两个实现：
AzureOpenAITextGenerator OpenAITextGenerator
配置示例：
// 配置文本生成模型 .WithAzureOpenAITextGeneration(new AzureOpenAIConfig { Deployment = "myai", Endpoint = "https://aaa.openai.azure.com/", Auth = AzureOpenAIConfig.AuthTypes.APIKey, APIKey = "aaa", APIType = AzureOpenAIConfig.APITypes.ChatCompletion })
导入文档时，首先将文档提取出文本，然后进行分段。
将每一段文本使用向量模型解析出向量，存储到 IMemoryDb 接口提供的服务中，如 Postgres数据库。
提问问题或搜索内容时，从 IMemoryDb 所在的位置搜索向量，查询到相关的文本，然后将文本收集起来，发送给 AI（使用文本生成模型），这些文本相对于提示词，然后 AI 从这些提示词中学习并回答用户的问题。
详细源码可以参考 Microsoft.KernelMemory.Search.SearchClient ，由于源码比较多，这里就不赘述了。
这样说，大家可能不太容易理解，我们可以用下面的代码做示范。
// 导入文档 await memory.ImportDocumentAsync( "aaa/(完整版)基础财务知识.docx", documentId: "doc02"); Console.WriteLine("正在处理文档，请稍等..."); while (!await memory.IsDocumentReadyAsync(documentId: "doc02")) { await Task.Delay(TimeSpan.FromMilliseconds(1500)); } var answer1 = await memory.SearchAsync("报表怎么做？"); // 每个 Citation 表示一个文档文件 foreach (Citation citation in answer1.Results) { // 与搜索关键词相关的文本 foreach(var partition in citation.Partitions) { Console.WriteLine(partition.Text); } } var answer2 = await memory.AskAsync("报表怎么做？"); Console.WriteLine($"\nAnswer: {answer2.Result}");
读者可以在 foreach 这里做个断点，当用户问题 “报表怎么做？” 时，搜索出来的相关文档。
然后再参考 Fastgpt 的搜索配置，可以自己写一个这样的知识库系统。
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]