Comment utiliser Semantic Kernel : Un guide pratique avec des modèles, des invites et des plugins
Avez-vous déjà essayé de coller un LLM à votre application et vous êtes-vous retrouvé avec un enchevêtrement fragile d'invites, de fonctions d'assistance et d'état ? Semantic Kernel (SK) existe pour résoudre exactement ce problème. Il s'agit d'un framework d'orchestration open source léger de Microsoft pour la création d'applications "AI-first" qui combinent le langage naturel, les outils et la mémoire, sans transformer votre code en un plat de spaghettis d'invites.
Dans ce guide, nous ferons un tour pratique et axé sur les solutions de la façon d'utiliser Semantic Kernel, de zéro aux modèles de production. Vous apprendrez à structurer les invites, à brancher des outils, à ajouter de la mémoire, à appeler plusieurs modèles et à déployer des agents qui agissent de manière cohérente. Nous garderons les exemples concrets et vous montrerons ce qui compte.
Qu'est-ce que Semantic Kernel et pourquoi l'utiliser ?
Semantic Kernel est un SDK qui vous aide à :
- Composer des invites et des fonctions (« skills »/plugins) en pipelines.
- Appeler plusieurs modèles (OpenAI, Azure OpenAI, modèles locaux) de manière interchangeable.
- Ajouter de la mémoire pour le contexte et le rappel à long terme via des embeddings.
- Planifier et orchestrer des tâches en plusieurs étapes avec un état fiable.
- Intégrer des outils (API, bases de données, E/S de fichiers) de manière sûre et déterministe.
Considérez SK comme le contrôleur qui coordonne les LLM, la logique de votre application et les données utilisateur. Au lieu de coder en dur de longues invites et des appels d'outils ad hoc, vous définissez des fonctions sémantiques réutilisables et des fonctions natives avec des entrées/sorties claires.
Cas d'utilisation courants :
- Copilotes de support client avec génération augmentée de récupération (RAG)
- Agents de workflow (résumer → classifier → agir)
- Questions-réponses sur les documents avec mémoire et citations
- Pipelines de génération de contenu créatif et de code
Démarrage rapide : Votre première application Semantic Kernel
Vous trouverez ci-dessous un flux minimal pour montrer comment utiliser Semantic Kernel avec un modèle de chat et une invite simple. Nous utiliserons C# pour plus de clarté ; vous pouvez faire de même en Python ou Java.
1) Installer les packages
# .NET
dotnet add package Microsoft.SemanticKernel
# Optionnel : les connecteurs et les planificateurs varient selon la version
2) Configurer le kernel et le modèle
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;
var builder = Kernel.CreateBuilder;
// Choisissez votre fournisseur : OpenAI ou Azure OpenAI
builder.AddOpenAIChatCompletion(
modelId: "gpt-4o-mini", // ou votre modèle préféré
apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);
var kernel = builder.Build;
3) Définir une fonction sémantique (invite)
using Microsoft.SemanticKernel.SemanticFunctions;
var prompt = @"Vous êtes un vulgarisateur concis.
Expliquez le concept de '{topic}' en 3 points pour un débutant.";
var explainFunc = kernel.CreateFunctionFromPrompt(prompt);
var result = await explainFunc.InvokeAsync(kernel, new { ["topic"] = "vector embeddings" });
Console.WriteLine(result);
Voici le cœur : un kernel, un modèle et une invite transformée en une fonction réutilisable avec des entrées.
Fonctions sémantiques vs. Fonctions natives
- Fonctions sémantiques : Alimentées par des invites. Vous les créez à partir de modèles, passez des variables et obtenez du texte ou des sorties structurées.
- Fonctions natives : Fonctions de code régulières que SK expose au LLM pour l'utilisation d'outils.
Exemple de fonction native qui récupère la météo de votre API et l'expose au modèle :
public class WeatherPlugin
{
[KernelFunction, Description("Get weather for a city")]
public async Task<string> GetWeatherAsync(
[Description("City name")] string city)
{
// Appelez votre API météo ici
var temp = 22; // espace réservé
return $"Météo à {city} : {temp}°C et ciel clair";
}
}
// Enregistrer le plugin
var weather = new WeatherPlugin;
kernel.Plugins.AddFromObject(weather, pluginName: "weather");
Maintenant, vos invites peuvent appeler weather.GetWeatherAsync comme un outil, permettant au modèle d'ancrer les réponses dans des données réelles.
Modèles d'invites qui fonctionnent réellement
Lorsque vous apprenez à utiliser Semantic Kernel, les gains les plus rapides proviennent de modèles d'invites disciplinés :
- Système d'abord : Utilisez un message système fort pour verrouiller le ton, le personnage, la sécurité et le format de sortie.
- Emplacements de variables : Nommez clairement les espaces réservés (par exemple,
{topic}, {audience}) et validez l'entrée.
- Contrats de sortie : Demandez des formats structurés comme JSON ; incluez un schéma dans l'invite.
- Few-shot : Fournissez des exemples concis pour le style et le format, pas de l'inflation de contenu.
- Garde-fous : Incluez des contraintes (« Si des données sont manquantes, posez d'abord une question de clarification »).
Exemple d'invite structurée à l'intérieur de SK :
var prompt = @"
Vous êtes un moteur de classification.
Tâche : Classifier le `message` dans l'une des catégories suivantes [Facturation, Support technique, Ventes].
Retourner un JSON strict : { \"label\": string, \"confidence\": number }
message: {message}
";
var classify = kernel.CreateFunctionFromPrompt(prompt);
var output = await classify.InvokeAsync(kernel, new { ["message"] = "Je n'arrive pas à me connecter à mon compte." });
Console.WriteLine(output); // {"label":"Tech Support","confidence":0.89}
Ajout de mémoire : Embeddings, RAG et fenêtres de contexte
Les LLM oublient. La mémoire les rend utiles.
- Contexte à court terme : Automatique via l'historique des conversations.
- Mémoire à long terme : Stockez les embeddings des notes, des documents ou des événements de l'utilisateur et récupérez les blocs pertinents pour le contexte.
- RAG : Avant d'appeler une fonction de génération, interrogez votre magasin de vecteurs et injectez les résultats dans l'invite.
Exemple : ajouter de la mémoire textuelle avec des embeddings et récupérer le contexte.
using Microsoft.SemanticKernel.Memory;
var memory = new MemoryBuilder
.WithMemoryStore(new VolatileMemoryStore) // échangez contre une base de données vectorielle (Qdrant, Pinecone, Azure AI Search)
.WithTextEmbeddingGeneration(
new OpenAITextEmbeddingGeneration("text-embedding-3-small", Environment.GetEnvironmentVariable("OPENAI_API_KEY")))
.Build;
await memory.SaveInformationAsync(
collection: "policies", id: "refund-policy",
text: "Les clients peuvent demander un remboursement dans les 30 jours suivant l'achat avec une preuve d'achat."
);
// Plus tard : récupérer et insérer dans l'invite
var results = memory.SearchAsync("refund window", collection: "policies", limit: 3, minRelevanceScore: 0.7);
await foreach (var item in results)
{
Console.WriteLine($"Pertinent : {item.Metadata.Text}");
}
Ensuite, alimentez les meilleures correspondances dans votre fonction sémantique en tant que variables de contexte. Conseil : gardez les blocs petits (200 à 400 tokens) et dédupliquez.
Utilisation des outils et planification : Workflows en plusieurs étapes
Semantic Kernel prend en charge les planificateurs qui peuvent décomposer un objectif utilisateur en étapes et choisir les fonctions à appeler. Ceci est parfait lorsque vous avez une boîte à outils de fonctions natives et sémantiques.
Modèle :
- Recueillir l'objectif et les contraintes de l'utilisateur.
- Rédiger un plan (séquence d'appels de fonctions avec des arguments).
- Exécuter étape par étape, vérifier les sorties et récupérer des erreurs.
Exemple de pseudocode :
// 1) Définir les plugins (sémantiques + natifs) comme avant
// 2) Utiliser un planificateur (la surface de l'API peut varier selon la version)
var goal = "Résumer la politique jointe, classifier le risque et envoyer un rapport par e-mail";
// Supposons que nous ayons des plugins : fichiers, résumé, classification, e-mail
// Le planificateur assemblera un plan : files.Load → summarize.Run → classify.Run → email.Send
// Exécuter le plan séquentiellement, valider les sorties JSON entre les étapes
Meilleures pratiques :
- Rendre les étapes idempotentes et testables.
- Définir des schémas de sortie explicites entre les étapes.
- Utiliser des tentatives/reculs sur les outils en réseau.
- Enregistrer les entrées/sorties pour l'observabilité (mais nettoyer les informations personnelles).
Stratégie multi-modèles : Choisir le bon modèle pour le travail
En utilisant Semantic Kernel, vous pouvez acheminer les tâches vers différents modèles :
- Brouillons rapides → modèles petits et bon marché
- Étapes nécessitant beaucoup de raisonnement → modèles plus grands
- Embeddings → modèle d'embedding spécialisé
- Code → modèles optimisés pour le code
En pratique :
var kernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey)
.Build;
var fastKernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey) // optimisé pour la vitesse
.Build;
// Acheminez les invites plus simples vers fastKernel ; les tâches complexes vers kernel
Ou, configurez plusieurs services dans le même kernel et sélectionnez-les par fonction.
Du prototype à la production : Garde-fous et tests
Lorsque vous apprenez à utiliser Semantic Kernel dans des applications réelles, la fiabilité compte :
- Sorties axées sur le schéma : Utilisez des schémas JSON et des portes
TryParse.
- Déterminisme si nécessaire : Définissez une température basse et contraignez les sorties.
- Filtres de sécurité : Ajoutez des filtres de contenu et des invites de red-team.
- Mise en cache : Mettez en cache les résultats RAG et les générations stables.
- Observabilité : Enregistrez les modèles d'invites, les variables, la latence, l'utilisation des tokens.
- Tests unitaires : Testez les invites dorées avec des comparaisons d'instantanés.
Exemple : valider la sortie JSON.
record Classification(string label, double confidence);
bool TryParseClassification(string text, out Classification cls)
{
try { cls = System.Text.Json.JsonSerializer.Deserialize<Classification>(text)!; return true; }
catch { cls = default!; return false; }
}
Modèles du monde réel que vous pouvez réutiliser
- Chatbot RAG :
retrieve(context) → answer(question, context) avec des citations.
- Workflows d'approbation : classifier → générer un brouillon → examen humain → envoyer.
- Opérations de contenu : outline → draft → fact-check → tone adjust → publish.
- Agent avec des outils : calendar.lookup, docs.search, email.send ; avec planification et mémoire.
Conseil : Encapsulez chaque étape en tant que fonction (sémantique ou native) et composez-les en pipelines.
Exemple : Questions-réponses sur les documents avec citations
Connectons un simple pipeline de questions-réponses qui cite les sources en utilisant RAG.
// 1) Ingérer les documents dans la mémoire
await memory.SaveInformationAsync("handbook", "vacation-policy",
"Les employés accumulent 1,5 jours de congés payés par mois et peuvent reporter 5 jours.");
// 2) Récupérer le contexte pour une question
var top = memory.SearchAsync("carry over PTO", "handbook", limit: 3, minRelevanceScore: 0.75);
var contexts = new List<string>;
await foreach (var r in top) contexts.Add(r.Metadata.Text);
// 3) Poser la question avec le contexte et demander des citations
var qaPrompt = @"
Vous répondez strictement à partir du contexte fourni. Si absent, dites que vous ne savez pas.
Incluez des citations en ligne comme [source i] en utilisant l'index des éléments de contexte commençant à 1.
Contexte :
1) {{ctx1}}
2) {{ctx2}}
Question : {{q}}
";
var qa = kernel.CreateFunctionFromPrompt(qaPrompt);
var variables = new KernelArguments
{
["ctx1"] = contexts.ElementAtOrDefault(0) ?? "",
["ctx2"] = contexts.ElementAtOrDefault(1) ?? "",
["q"] = "Combien de jours de congés payés puis-je reporter ?"
};
var answer = await qa.InvokeAsync(kernel, variables);
Console.WriteLine(answer);
Pièges courants (et comment les éviter)
- Une seule invite géante : Divisez en fonctions ; passez seulement le contexte dont vous avez besoin.
- Pas de contrats de sortie : Définissez toujours des schémas pour les étapes lisibles par machine.
- RAG sans hygiène : Segmentez bien, dédupliquez et classez par pertinence et récence.
- Prolifération d'outils : Gardez les interfaces de plugin petites et documentées.
- Pas d'humain dans la boucle : Ajoutez des approbations pour les actions à haut risque.
Comment utiliser Semantic Kernel avec les frontends
- Applications web : Hébergez votre orchestration SK dans une couche API ; diffusez des tokens vers l'interface utilisateur.
- Interfaces utilisateur de chat : Maintenez l'état de la conversation côté serveur ; élaguez et résumez.
- Authentification : Appels sécurisés par l'emprunt d'identité - ne laissez jamais le modèle créer des tokens. Contrôlez les appels d'outils via votre backend.
Liste de contrôle de déploiement
- Variables d'environnement pour les clés et les points de terminaison
- Limitation du débit et nouvelles tentatives pour les appels de modèle/outil
- Contrôle de source des modèles d'invites
- Sauvegardes du magasin de vecteurs et gestion des informations personnelles
- Tableaux de bord d'observabilité (latence, coût, erreurs)
- Tests A/B pour les invites et le routage
Dépannage de style FAQ
- « Le modèle hallucine même avec RAG. » Renforcez les instructions : « Répondez seulement à partir du contexte » et incluez un exemple de refus. Augmentez la spécificité de la récupération et réduisez la température.
- « JSON continue de se casser. » Ajoutez un mini-exemple de JSON valide et interdisez les commentaires. Post-validez et reformulez en cas d'échec.
- « La latence est élevée. » Récupérez moins de blocs, mais plus pertinents ; basculez les étapes simples vers des modèles plus petits ; parallélisez les étapes indépendantes.
- « Les coûts montent en flèche. » Mettez en cache, compressez le contexte et acheminez les tâches faciles vers des modèles moins chers.
À noter : Construisez plus rapidement avec Sider.AI
Si vous prototypez des invites, testez des flux d'outils ou comparez des réponses entre les modèles, un compagnon comme Sider.ai peut accélérer l'itération. Vous pouvez rédiger des invites, exécuter des comparaisons A/B et capturer des extraits réutilisables avant de les déplacer dans des modèles Semantic Kernel, ce qui est idéal pour affiner les instructions et les schémas de sortie. Prochaines étapes : Transformez cela en un agent de travail
- Commencez par une tâche claire (par exemple, classifier les e-mails de support).
- Définissez des fonctions sémantiques/natives avec des entrées/sorties strictes.
- Ajoutez de la mémoire seulement là où cela améliore mesurablement les réponses.
- Instrumentez tout ; testez avec des échantillons du monde réel.
- Itérez sur les invites en utilisant un bac à sable, puis codifiez dans SK.
Principaux points à retenir :
- Semantic Kernel vous aide à composer des invites, des outils et de la mémoire en workflows fiables.
- Utilisez des schémas de sortie, des planificateurs et un routage multi-modèles pour la robustesse et le contrôle des coûts.
- RAG plus des garde-fous bat les invites géantes à chaque fois.
Une fois que vous maîtrisez l'utilisation de Semantic Kernel avec ces modèles, vous livrerez des fonctionnalités d'IA qui ne sont pas seulement des démos impressionnantes, mais des systèmes fiables.
FAQ
Q1 : À quoi sert Semantic Kernel dans les applications d'IA ?
Semantic Kernel est un SDK d'orchestration pour la création de workflows d'IA qui combinent des invites LLM, des outils (fonctions natives) et de la mémoire. Il vous aide à structurer les tâches, à ajouter RAG et à appeler plusieurs modèles de manière fiable.
Q2 : Comment utiliser Semantic Kernel pour RAG avec mes documents ?
Ingérez vos documents dans un magasin de vecteurs via les API de mémoire de SK, puis récupérez les blocs les plus pertinents par requête et injectez-les dans votre invite. Cela améliore la précision et réduit les hallucinations.
Q3 : Semantic Kernel peut-il appeler des API et des services externes ?
Oui. Enveloppez les API en tant que fonctions natives dans un plugin et enregistrez-les auprès du kernel afin que le modèle puisse les utiliser comme outils. Gardez les interfaces petites et appliquez la validation des entrées/sorties.
Q4 : Quels modèles fonctionnent avec Semantic Kernel ?
Semantic Kernel prend en charge OpenAI, Azure OpenAI et d'autres connecteurs. Vous pouvez acheminer les tâches vers différents modèles, par exemple, des modèles plus petits pour les brouillons et des modèles plus grands pour les étapes nécessitant beaucoup de raisonnement.
Q5 : Comment rendre les sorties de Semantic Kernel cohérentes (par exemple, JSON) ?
Utilisez des invites structurées qui exigent un JSON strict et incluez un exemple ou un schéma minimal. Définissez une température basse, validez les sorties après l'appel et réessayez ou réparez lorsque l'analyse échoue.