Présentation du noyau
Le noyau est le composant central du noyau sémantique. À son niveau le plus simple, le noyau est un conteneur d’injection de dépendances qui gère tous les services et plug-ins nécessaires pour exécuter votre application IA. Si vous fournissez tous vos services et plug-ins au noyau, ils seront ensuite utilisés en toute transparence par l’IA en fonction des besoins.
Le noyau est au centre
Étant donné que le noyau dispose de tous les services et plug-ins nécessaires pour exécuter à la fois du code natif et des services IA, il est utilisé par presque tous les composants du SDK de noyau sémantique pour alimenter vos agents. Cela signifie que si vous exécutez une invite ou du code dans le noyau sémantique, le noyau sera toujours disponible pour récupérer les services et plug-ins nécessaires.
Cela est extrêmement puissant, car cela signifie que vous en tant que développeur disposez d’un emplacement unique où vous pouvez configurer, et plus important encore surveiller, vos agents IA. Par exemple, lorsque vous appelez une invite à partir du noyau. Lorsque vous le faites, le noyau sera...
- Sélectionnez le meilleur service IA pour exécuter l’invite.
- Générez l’invite à l’aide du modèle d’invite fourni.
- Envoyez l’invite au service IA.
- Recevez et analysez la réponse.
- Enfin, retournez la réponse du LLM à votre application.
Tout au long de ce processus, vous pouvez créer des événements et des intergiciels déclenchés à chacune de ces étapes. Cela signifie que vous pouvez effectuer des actions telles que la journalisation, fournir des mises à jour d’état aux utilisateurs, et plus important responsable de l’IA. Tout à partir d’un seul endroit.
Créer un noyau avec des services et des plug-ins
Avant de créer un noyau, vous devez d’abord comprendre les deux types de composants qui existent :
| Composants | Description | |
|---|---|---|
| 1 | Services | Il s’agit des deux services IA (par exemple, la saisie semi-automatique de conversation) et d’autres services (par exemple, la journalisation et les clients HTTP) nécessaires pour exécuter votre application. Cela a été modélisé après le modèle fournisseur de services dans .NET afin que nous puissions prendre en charge l’ingestion de dépendances dans tous les langages. |
| 2 | Plug-ins | Il s’agit des composants qui sont utilisés par vos services IA et invitent des modèles à effectuer un travail. Par exemple, les services IA peuvent utiliser des plug-ins pour récupérer des données à partir d’une base de données ou appeler une API externe pour effectuer des actions. |
Pour commencer à créer un noyau, importez les packages nécessaires en haut de votre fichier :
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Plugins.Core;
Ensuite, vous pouvez ajouter des services et des plug-ins. Voici un exemple de la façon dont vous pouvez ajouter une saisie semi-automatique de conversation Azure OpenAI, un enregistreur d’événements et un plug-in de temps.
// Create a kernel with a logger and Azure OpenAI chat completion service
var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(modelId, endpoint, apiKey);
builder.Services.AddLogging(c => c.AddDebug().SetMinimumLevel(LogLevel.Trace));
builder.Plugins.AddFromType<TimePlugin>();
Kernel kernel = builder.Build();
Importez les packages nécessaires :
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.core_plugins.time_plugin import TimePlugin
Ensuite, vous pouvez créer un noyau.
# Initialize the kernel
kernel = Kernel()
Enfin, vous pouvez ajouter les services et plug-ins nécessaires. Voici un exemple de la façon dont vous pouvez ajouter une saisie semi-automatique de conversation Azure OpenAI, un enregistreur d’événements et un plug-in de temps.
# Add the Azure OpenAI chat completion service
kernel.add_service(AzureChatCompletion(model_id, endpoint, api_key))
# Add a plugin
kernel.add_plugin(
TimePlugin(),
plugin_name="TimePlugin",
)
Générer un noyau
Les noyaux peuvent être générés à l’aide d’un Kernel.builder(). Sur ce point, vous pouvez ajouter les services et plug-ins IA requis.
Kernel kernel = Kernel.builder()
.withAIService(ChatCompletionService.class, chatCompletionService)
.withPlugin(lightPlugin)
.build();
Utilisation de l’injection de dépendances
En C#, vous pouvez utiliser l’injection de dépendances pour créer un noyau. Pour ce faire, créez un ServiceCollection service et ajoutez des plug-ins à celui-ci. Voici un exemple de création d’un noyau à l’aide de l’injection de dépendances.
Conseil
Nous vous recommandons de créer un noyau en tant que service temporaire afin qu’il soit supprimé après chaque utilisation, car la collection de plug-ins est mutable. Le noyau est extrêmement léger (car il s’agit simplement d’un conteneur pour les services et les plug-ins), de sorte que la création d’un nouveau noyau pour chaque utilisation n’est pas un problème de performances.
using Microsoft.SemanticKernel;
var builder = Host.CreateApplicationBuilder(args);
// Add the OpenAI chat completion service as a singleton
builder.Services.AddOpenAIChatCompletion(
modelId: "gpt-4",
apiKey: "YOUR_API_KEY",
orgId: "YOUR_ORG_ID", // Optional; for OpenAI deployment
serviceId: "YOUR_SERVICE_ID" // Optional; for targeting specific services within Semantic Kernel
);
// Create singletons of your plugins
builder.Services.AddSingleton(() => new LightsPlugin());
builder.Services.AddSingleton(() => new SpeakerPlugin());
// Create the plugin collection (using the KernelPluginFactory to create plugins from objects)
builder.Services.AddSingleton<KernelPluginCollection>((serviceProvider) =>
[
KernelPluginFactory.CreateFromObject(serviceProvider.GetRequiredService<LightsPlugin>()),
KernelPluginFactory.CreateFromObject(serviceProvider.GetRequiredService<SpeakerPlugin>())
]
);
// Finally, create the Kernel service with the service provider and plugin collection
builder.Services.AddTransient((serviceProvider)=> {
KernelPluginCollection pluginCollection = serviceProvider.GetRequiredService<KernelPluginCollection>();
return new Kernel(serviceProvider, pluginCollection);
});
Conseil
Pour plus d’exemples sur l’utilisation de l’injection de dépendances en C#, reportez-vous aux exemples de concept.
Étapes suivantes
Maintenant que vous comprenez le noyau, vous pouvez en savoir plus sur tous les différents services IA que vous pouvez y ajouter.