Übersicht über den semantischen Kernel für .NET
In diesem Artikel erkunden Sie Kernkonzepte und -funktionen des semantischen Kernel. Der semantische Kernel ist eine leistungsstarke und empfohlene Wahl für die Arbeit mit KI in .NET-Anwendungen. In den nächsten Abschnitten lernen Sie Folgendes:
- Hinzufügen des semantischen Kernels zu Ihrem Projekt
- Kernkonzepte des semantischen Kernels
Dieser Artikel vermittelt einen ersten Überblick über den semantischen Kernel speziell im Kontext von .NET. Ausführlichere Informationen und Schulungen zum semantischen Kernel finden Sie in den folgenden Ressourcen:
Hinzufügen des semantischen Kernels zu einem .NET-Projekt
Das SDK für den semantischen Kernel ist als NuGet-Paket für .NET verfügbar und kann in Standard-App-Konfigurationen integriert werden.
Installieren Sie das Paket Microsoft.SemanticKernel mit dem folgenden Befehl:
dotnet add package Microsoft.SemanticKernel
Hinweis
Obwohl Microsoft.SemanticKernel Kernfunktionen des semantischen Kernels bietet, müssen Sie für weitere Funktionen zusätzliche Pakete installieren. Beispielsweise bietet das Paket Microsoft.SemanticKernel.Plugins.Memory Zugriff auf arbeitsspeicherbezogene Features. Weitere Informationen finden Sie in der Dokumentation zum semantischen Kernel.
Erstellen und konfigurieren Sie eine Kernel-Instanz mithilfe der KernelBuilder-Klasse für den Zugriff auf den semantischen Kernel und die Arbeit mit ihm. Der Kernel enthält Dienste, Daten und Verbindungen zur Orchestrierung von Integrationen zwischen Ihrem Code und KI-Modellen.
Konfigurieren des Kernel in einer .NET-Konsolen-App:
var builder = Kernel.CreateBuilder();
// Add builder configuration and services
var kernel = builder.Build();
Konfigurieren des Kernels in einer ASP.NET Core-App:
var builder = WebApplication.CreateBuilder();
builder.Services.AddKernel();
// Add builder configuration and services
var app = builder.Build();
Grundlegendes zum semantischen Kernel
Der semantische Kernel ist ein Open-Source-SDK, das KI-Modelle und -Dienste wie OpenAI, Azure OpenAI und Hugging Face in herkömmliche Programmiersprachen wie C#, Python und Java integriert und koordiniert.
Das SDK für den semantischen Kernel hilft Unternehmensentwicklern auf folgende Weise:
- Es optimiert die Integration von KI-Funktionen in vorhandene Anwendungen und ermöglicht so eine zusammenhängende Lösung für Unternehmensprodukte.
- Es minimiert die Lernkurve der Arbeit mit verschiedenen KI-Modellen oder -Diensten, indem Abstraktionen bereitgestellt werden, die die Komplexität reduzieren.
- Es verbessert die Zuverlässigkeit, indem das unvorhersehbare Verhalten von Prompts und Antworten von KI-Modellen reduziert wird. Sie können Prompts optimieren und Aufgaben planen, um eine kontrollierte und vorhersehbare Benutzerumgebung zu erstellen.
Der semantische Kernel basiert auf mehreren Kernkonzepten:
- Verbindungen: Schnittstelle mit externen KI-Diensten und Datenquellen.
- Plug-Ins: kapseln Funktionen, die Anwendungen verwenden können.
- Planner: koordiniert Ausführungspläne und Strategien basierend auf dem Benutzerverhalten.
- Speicher: abstrahiert und vereinfacht die Kontextverwaltung für KI-Apps.
In den folgenden Abschnitten werden diese Bausteine näher erläutert.
Verbindungen
Das SDK für den semantischen Kernel enthält eine Reihe von Connectors, mit denen Entwickler LLMs und andere Dienste in ihre vorhandenen Anwendungen integrieren können. Diese Connectors dienen als Brücke zwischen dem Anwendungscode und den KI-Modellen oder -Diensten. Der semantische Kernel behandelt viele häufige Verbindungsaspekte und -herausforderungen für Sie, damit Sie sich auf die Erstellung eigener Workflows und Features konzentrieren können.
Der folgende Codeschnipsel erstellt einen Kernel und fügt eine Verbindung mit einem Azure OpenAI-Modell hinzu:
using Microsoft.SemanticKernel;
// Create kernel
var builder = Kernel.CreateBuilder();
// Add a chat completion service:
builder.Services.AddAzureOpenAIChatCompletion(
"your-resource-name",
"your-endpoint",
"your-resource-key",
"deployment-model");
var kernel = builder.Build();
Plug-Ins
Plug-Ins für den semantischen Kernel kapseln Standardsprachfunktionen für Anwendungen und KI-Modelle, die verwendet werden sollen. Sie können eigene Plug-Ins erstellen oder sich auf Plug-Ins berufen, die vom SDK bereitgestellt werden. Diese Plug-Ins optimieren Aufgaben, bei denen KI-Modelle vorteilhaft und effizient mit herkömmlicheren C#-Methoden kombiniert werden. Plug-In-Funktionen werden in der Regel in zwei Typen unterteilt: semantische Funktionen und native Funktionen.
Semantische Funktionen
Semantische Funktionen sind im Wesentlichen KI-Prompts, die in Ihrem Code definiert sind und die der semantische Kernel nach Bedarf anpassen und aufrufen kann. Sie können diese Prompts zur Verwendung von Variablen, benutzerdefinierter Prompt- und Vervollständigungsformatierung und mehr in Vorlagen integrieren.
Der folgende Codeschnipsel definiert und registriert eine semantische Funktion:
var userInput = Console.ReadLine();
// Define semantic function inline.
string skPrompt = @"Summarize the provided unstructured text in a sentence that is easy to understand.
Text to summarize: {{$userInput}}";
// Register the function
kernel.CreateSemanticFunction(
promptTemplate: skPrompt,
functionName: "SummarizeText",
pluginName: "SemanticFunctions"
);
Native Funktionen
Native Funktionen sind C#-Methoden, die der semantische Kernel direkt aufrufen kann, um Daten zu bearbeiten oder abzurufen. Sie führen Vorgänge aus, die besser für herkömmliche Codeanweisungen geeignet sind als LLM-Prompts.
Der folgende Codeschnipsel definiert und registriert eine native Funktion:
// Define native function
public class NativeFunctions {
[SKFunction, Description("Retrieve content from local file")]
public async Task<string> RetrieveLocalFile(string fileName, int maxSize = 5000)
{
string content = await File.ReadAllTextAsync(fileName);
if (content.Length <= maxSize) return content;
return content.Substring(0, maxSize);
}
}
//Import native function
string plugInName = "NativeFunction";
string functionName = "RetrieveLocalFile";
var nativeFunctions = new NativeFunctions();
kernel.ImportFunctions(nativeFunctions, plugInName);
Planner
Der Planner ist eine Kernkomponente des semantischen Kernels, die KI-Orchestrierung bietet, um die nahtlose Integration zwischen KI-Modellen und Plug-Ins zu verwalten. Diese Ebene entwickelt Ausführungsstrategien von Benutzeranforderungen und koordiniert Plug-Ins dynamisch, um komplexe Aufgaben mit KI-unterstützter Planung durchzuführen.
Betrachten Sie den folgenden Pseudocodeschipsel:
// Native function definition and kernel configuration code omitted for brevity
// Configure and create the plan
string planDefinition = "Read content from a local file and summarize the content.";
SequentialPlanner sequentialPlanner = new SequentialPlanner(kernel);
string assetsFolder = @"../../assets";
string fileName = Path.Combine(assetsFolder,"docs","06_SemanticKernel", "aci_documentation.txt");
ContextVariables contextVariables = new ContextVariables();
contextVariables.Add("fileName", fileName);
var customPlan = await sequentialPlanner.CreatePlanAsync(planDefinition);
// Execute the plan
KernelResult kernelResult = await kernel.RunAsync(contextVariables, customPlan);
Console.WriteLine($"Summarization: {kernelResult.GetValue<string>()}");
Mit dem vorstehenden Code wird ein ausführbarer, sequenzieller Plan zum Lesen von Inhalten aus einer lokalen Datei erstellt, und die Inhalte werden zusammengefasst. Der Plan richtet Anweisungen ein, um die Datei mithilfe einer nativen Funktion zu lesen und dann mithilfe eines KI-Modells zu analysieren.
Arbeitsspeicher
Die Vektorspeicher des semantischen Kernel stellen Abstraktionen zum Einbetten von Modellen, Vektordatenbanken und anderen Daten bereit, um das Kontextmanagement für KI-Anwendungen zu vereinfachen. Vektorspeicher sind von der zugrunde liegenden LLM- oder Vektordatenbank unabhängig und bieten eine einheitliche Entwicklererfahrung. Sie können Speicherfeatures konfigurieren, um Daten in einer Vielzahl von Quellen oder Diensten zu speichern, einschließlich Azure KI-Suche und Azure Cache for Redis.
Betrachten Sie den folgenden Codeausschnitt:
var facts = new Dictionary<string,string>();
facts.Add(
"Azure Machine Learning; https://learn.microsoft.com/en-us/azure/machine-learning/",
@"Azure Machine Learning is a cloud service for accelerating and
managing the machine learning project lifecycle. Machine learning professionals,
data scientists, and engineers can use it in their day-to-day workflows"
);
facts.Add(
"Azure SQL Service; https://learn.microsoft.com/en-us/azure/azure-sql/",
@"Azure SQL is a family of managed, secure, and intelligent products
that use the SQL Server database engine in the Azure cloud."
);
string memoryCollectionName = "SummarizedAzureDocs";
foreach (var fact in facts) {
await memoryBuilder.SaveReferenceAsync(
collection: memoryCollectionName,
description: fact.Key.Split(";")[1].Trim(),
text: fact.Value,
externalId: fact.Key.Split(";")[2].Trim(),
externalSourceName: "Azure Documentation"
);
}
Der vorstehende Code lädt eine Gruppe von Fakten in den Speicher, sodass die Daten bei der Interaktion mit KI-Modellen und bei Orchestrierungsaufgaben zur Verfügung stehen.
