Semantic Kernel : guide complet du SDK IA Microsoft en Python

Introduction

Les équipes enterprise qui veulent intégrer des LLM dans des applications .NET ou Python se heurtent rapidement au même problème : comment structurer le code, gérer les prompts, orchestrer plusieurs modèles et brancher des outils métier sans repartir de zéro à chaque projet ? Semantic Kernel est la réponse de Microsoft à cette question. C'est un SDK open-source (licence MIT) qui fournit une couche d'abstraction entre votre code applicatif et les LLM — compatible Azure OpenAI, OpenAI, et d'autres fournisseurs. Ce guide vous montre comment l'utiliser en Python pour construire des agents capables d'appeler des plugins, de planifier des tâches et de maintenir une mémoire persistante.

Résumé rapide

Critère	Semantic Kernel
Langage principal	Python, C#, Java
Soutenu par	Microsoft (production depuis 2023)
Modèles supportés	Azure OpenAI, OpenAI, Hugging Face, Ollama
Concept central	Kernel + Plugins + Functions
Cas d'usage idéal	Applications enterprise, intégration Azure, assistants métier
vs CrewAI	SK = SDK d'intégration LLM ; CrewAI = orchestration multi-agents avec rôles
vs AutoGen	SK = plugins et planification ; AutoGen = conversation multi-agents dynamique

Semantic Kernel n'est pas un framework d'orchestration multi-agents comme CrewAI ou AutoGen. C'est un SDK d'intégration : il gère l'appel aux LLM, les fonctions/plugins, la mémoire et la planification dans une application existante. Pour des agents conversationnels multi-rôles, CrewAI ou AutoGen seront plus adaptés.

Ce qu'est Semantic Kernel

Positionnement Microsoft

Microsoft a lancé Semantic Kernel en 2023 pour accompagner l'adoption d'Azure OpenAI Service en entreprise. Le SDK est open-source (GitHub : microsoft/semantic-kernel) et activement maintenu — plus de 400 contributeurs, mises à jour hebdomadaires. Il est utilisé en production dans des produits Microsoft (Copilot Studio, Azure AI Foundry) ce qui lui confère une stabilité inhabituelle pour un projet de cet âge.

L'objectif déclaré : permettre aux développeurs d'ajouter des capacités IA à des applications existantes sans réécrire toute l'architecture. SK s'intègre dans une application .NET ou Python comme une bibliothèque ordinaire.

Architecture du SDK

Le composant central est le Kernel. C'est un registre de services (LLM, mémoire, logging) et de plugins. Tous les autres composants interagissent via le Kernel.

┌──────────────────────────────────────────────┐
│                   KERNEL                      │
│                                               │
│  Services ──► LLM (Azure OpenAI / OpenAI)    │
│               Memory (Vector Store)           │
│               Logging                         │
│                                               │
│  Plugins ──► Plugin A (fonctions métier)     │
│              Plugin B (recherche web)         │
│              Plugin C (base de données)       │
│                                               │
│  Planners ──► FunctionChoiceBehavior          │
│               (sélection automatique)         │
└──────────────────────────────────────────────┘

Les Plugins regroupent des Functions — fonctions Python ordinaires annotées avec des métadonnées que le LLM peut lire pour décider de les appeler. La mémoire (Memory / VectorStore) permet de stocker et récupérer des informations via embeddings. Les Planners (aujourd'hui principalement via FunctionChoiceBehavior) permettent au LLM de choisir automatiquement quelles fonctions invoquer.

Disponibilité Python

Le support Python de SK a rattrapé le support C# depuis la version 1.0 (fin 2024). Toutes les fonctionnalités clés sont disponibles : plugins, chat completion, streaming, mémoire vectorielle, agents avec Agent Framework. Le package PyPI est semantic-kernel.

Concepts clés, installation et exemples

Installation

pip install semantic-kernel
# Pour Azure OpenAI
pip install semantic-kernel[azure]
# Pour la mémoire vectorielle avec Chroma
pip install semantic-kernel[chroma]

Version stable recommandée : >=1.0.0. Vérifiez la compatibilité Python : SK requiert Python 3.10+.

Configuration du Kernel

Deux fournisseurs courants : Azure OpenAI et OpenAI. La configuration se fait via variables d'environnement ou directement dans le code.

Avec Azure OpenAI :

import os
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

kernel = Kernel()

kernel.add_service(
    AzureChatCompletion(
        deployment_name=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
        api_key=os.environ["AZURE_OPENAI_API_KEY"],
    )
)

Avec OpenAI :

from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion

kernel = Kernel()
kernel.add_service(
    OpenAIChatCompletion(
        ai_model_id="gpt-4o",
        api_key=os.environ["OPENAI_API_KEY"],
    )
)

Plugins et Functions

Un Plugin est une classe Python dont les méthodes sont annotées avec @kernel_function. Ces annotations exposent le nom, la description et les paramètres au LLM, qui peut ainsi décider de les appeler.

from semantic_kernel.functions import kernel_function

class EmailPlugin:
    """Plugin pour gérer les emails de l'utilisateur."""

    @kernel_function(
        name="get_unread_emails",
        description="Récupère les emails non lus. Retourne une liste de sujets et expéditeurs."
    )
    def get_unread_emails(self) -> str:
        # Connexion à l'API email ici
        return "- De: alice@example.com | Sujet: Rapport Q1\n- De: bob@example.com | Sujet: Réunion vendredi"

    @kernel_function(
        name="send_email",
        description="Envoie un email. Paramètres: to (destinataire), subject (sujet), body (corps du message)."
    )
    def send_email(self, to: str, subject: str, body: str) -> str:
        # Envoi réel via SMTP ou API ici
        return f"Email envoyé à {to} avec le sujet '{subject}'."

Enregistrement du plugin dans le Kernel :

kernel.add_plugin(EmailPlugin(), plugin_name="email")

FunctionChoiceBehavior : invocation automatique des fonctions

Pour qu'un agent choisisse et appelle automatiquement les fonctions selon le besoin de l'utilisateur, SK utilise FunctionChoiceBehavior. Le LLM reçoit les descriptions des fonctions disponibles et décide lesquelles invoquer.

from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.contents.chat_history import ChatHistory

chat_service = kernel.get_service(type=AzureChatCompletion)

execution_settings = OpenAIChatPromptExecutionSettings(
    function_choice_behavior=FunctionChoiceBehavior.Auto(
        filters={"included_plugins": ["email"]}
    )
)

history = ChatHistory()
history.add_user_message("Quels emails non lus ai-je ? Résume-les.")

result = await chat_service.get_chat_message_content(
    chat_history=history,
    settings=execution_settings,
    kernel=kernel,
)
print(result)

SK gère la boucle d'appel : le LLM signale qu'il veut appeler get_unread_emails, SK l'exécute, renvoie le résultat au LLM, et le LLM produit la réponse finale. Tout cela en une seule invocation depuis votre code.

Mémoire et VectorStore

SK intègre une couche d'abstraction pour les bases vectorielles (in-memory, Chroma, Azure AI Search, Qdrant, etc.). Elle sert principalement pour le RAG (Retrieval-Augmented Generation).

from semantic_kernel.memory.semantic_text_memory import SemanticTextMemory
from semantic_kernel.connectors.memory.chroma import ChromaMemoryStore
from semantic_kernel.connectors.ai.open_ai import OpenAITextEmbedding

embedding_service = OpenAITextEmbedding(
    ai_model_id="text-embedding-3-small",
    api_key=os.environ["OPENAI_API_KEY"],
)

memory = SemanticTextMemory(
    storage=ChromaMemoryStore(persist_directory="./chroma_db"),
    embeddings_generator=embedding_service,
)

# Stocker une information
await memory.save_information(
    collection="company_docs",
    id="doc_001",
    text="La politique de congés prévoit 25 jours par an pour les employés à temps plein.",
)

# Recherche sémantique
results = await memory.search("company_docs", "combien de jours de vacances ai-je ?")
for r in results:
    print(r.text, r.relevance)

Agent Framework (SK 1.x)

SK 1.x introduit un Agent Framework inspiré d'AutoGen, avec ChatCompletionAgent et AgentGroupChat pour des scénarios multi-agents. Un agent simple :

from semantic_kernel.agents import ChatCompletionAgent

agent = ChatCompletionAgent(
    kernel=kernel,
    name="AssistantEmail",
    instructions="Tu es un assistant qui gère les emails. Sois concis et précis.",
)

response = await agent.get_response(messages="Liste mes emails non lus et propose des réponses.")
print(response.content)

Exemple concret : agent assistant d'email avec mémoire

Voici un agent complet qui combine plugin email, mémoire des préférences utilisateur et appels automatiques de fonctions.

import asyncio
import os
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, OpenAIChatPromptExecutionSettings
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior
from semantic_kernel.contents.chat_history import ChatHistory
from semantic_kernel.functions import kernel_function

class EmailPlugin:
    @kernel_function(name="get_unread_emails", description="Récupère les emails non lus de l'utilisateur.")
    def get_unread_emails(self) -> str:
        return (
            "1. De: cto@company.com | Sujet: Review architecture Q2 | Priorité: haute\n"
            "2. De: rh@company.com | Sujet: Formulaire congés | Priorité: normale\n"
            "3. De: newsletter@saas.io | Sujet: Nouveautés avril | Priorité: basse"
        )

    @kernel_function(
        name="draft_reply",
        description="Rédige une réponse à un email. Paramètres: email_id (numéro), tone (ton: formel/informel)."
    )
    def draft_reply(self, email_id: str, tone: str = "formel") -> str:
        drafts = {
            "1": f"Bonjour,\nMerci pour votre message concernant la revue architecture Q2. Je reviendrai vers vous avant la fin de semaine.\nCordialement",
            "2": f"Bonjour,\nBien reçu pour le formulaire congés. Je le compléterai aujourd'hui.\nCordialement",
        }
        return drafts.get(email_id, "Email introuvable.")

async def run_email_agent():
    kernel = Kernel()
    kernel.add_service(
        AzureChatCompletion(
            deployment_name=os.environ["AZURE_OPENAI_DEPLOYMENT"],
            endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
            api_key=os.environ["AZURE_OPENAI_API_KEY"],
        )
    )
    kernel.add_plugin(EmailPlugin(), plugin_name="email")

    chat_service = kernel.get_service(type=AzureChatCompletion)
    settings = OpenAIChatPromptExecutionSettings(
        function_choice_behavior=FunctionChoiceBehavior.Auto()
    )

    history = ChatHistory()
    history.add_system_message(
        "Tu es un assistant de gestion d'emails. "
        "Utilise les outils disponibles pour aider l'utilisateur. "
        "Classe les emails par priorité et propose des actions concrètes."
    )
    history.add_user_message(
        "Montre-moi mes emails non lus et rédige une réponse formelle pour l'email de priorité haute."
    )

    result = await chat_service.get_chat_message_content(
        chat_history=history,
        settings=settings,
        kernel=kernel,
    )
    print(result)

if __name__ == "__main__":
    asyncio.run(run_email_agent())

Ce code est directement exécutable avec les variables d'environnement Azure OpenAI configurées. SK orchestre les deux appels de fonctions (get_unread_emails, puis draft_reply) sans que vous ayez à gérer cette logique manuellement.

Bonnes pratiques

Erreurs fréquentes :

Descriptions de fonctions trop vagues : le LLM décide d'appeler une fonction uniquement sur la base de sa description. Une description imprécise entraîne des appels manqués ou incorrects. Soyez explicite sur les paramètres attendus et le format de retour.
Oublier await : la quasi-totalité des opérations SK en Python sont asynchrones. Exécuter sans await retourne un coroutine non exécutée — erreur silencieuse difficile à débugger.
Ne pas limiter les plugins exposés : avec FunctionChoiceBehavior.Auto(), tous les plugins enregistrés sont exposés au LLM. Sur des applications avec de nombreux plugins, utilisez le filtre included_plugins pour limiter le contexte et réduire les coûts token.

Couplage Azure :

SK fonctionne parfaitement avec OpenAI standard, mais certaines fonctionnalités (Azure AI Search comme vector store, authentification via Managed Identity) sont spécifiques Azure. Si vous voulez rester agnostique au cloud, utilisez uniquement les connecteurs génériques (OpenAI, Chroma, Qdrant).

Planners dépréciés :

Les anciens SequentialPlanner et StepwisePlanner de SK 0.x sont dépréciés depuis SK 1.0. Migrez vers FunctionChoiceBehavior et l'Agent Framework. Ne reproduisez pas d'exemples trouvés sur des articles antérieurs à 2024.

Quand SK n'est pas adapté :

Vous avez besoin d'orchestrer plusieurs agents avec des rôles différents en parallèle : préférez AutoGen ou CrewAI.
Votre pipeline est entièrement déterministe (pas de décision LLM) : un simple script ou LangChain suffit.
Vous n'êtes pas en contexte .NET/Azure : SK apporte moins de valeur ajoutée hors de cet écosystème.

FAQ

Semantic Kernel fonctionne-t-il sans Azure ?

Oui. SK supporte OpenAI directement, ainsi que des modèles locaux via Ollama et des modèles Hugging Face. Azure n'est pas obligatoire. L'intégration Azure (Azure OpenAI Service, Azure AI Search, Managed Identity) est facilitée, mais le SDK reste utilisable avec n'importe quel fournisseur OpenAI-compatible.

Quelle est la différence entre Semantic Kernel et LangChain ?

LangChain est un framework d'orchestration de chaînes et d'agents, principalement Python, avec un écosystème d'intégrations très large. SK est un SDK d'intégration LLM orienté enterprise, avec un fort support C# et une intégration native Azure. SK priorise la fiabilité et la sécurité enterprise ; LangChain priorise la flexibilité et la richesse des intégrations.

Les Planners de Semantic Kernel sont-ils encore utilisables ?

Les anciens planners (SequentialPlanner, HandlebarsPlanner) fonctionnent encore mais sont officiellement dépréciés dans SK 1.x. L'approche recommandée est FunctionChoiceBehavior.Auto() combiné à l'Agent Framework. Évitez les planners legacy pour tout nouveau projet.

Semantic Kernel est-il prêt pour la production ?

Oui, depuis la version 1.0 (fin 2024). Microsoft l'utilise en production dans Copilot Studio et Azure AI Foundry. La stabilité de l'API Python est garantie à partir de la v1.0. Vérifiez le changelog avant chaque mise à jour majeure — les versions 0.x avaient des breaking changes fréquents.

Comment gérer plusieurs LLM dans le même Kernel ?

SK supporte l'enregistrement de plusieurs services avec des identifiants distincts. Vous pouvez enregistrer GPT-4o pour les tâches complexes et un modèle plus léger pour les embeddings ou les tâches simples, puis sélectionner le service par ID lors de l'invocation.

Articles liés

Pour aller plus loin sur les frameworks d'agents IA et l'écosystème Microsoft, plusieurs ressources complètent ce guide. AutoGen (aussi de Microsoft) est l'alternative orientée conversations multi-agents dynamiques, tandis que le guide général sur les agents IA donne le contexte pour choisir le bon framework selon votre cas d'usage.

Guide complet des agents IA en 2026 — comprendre les agents, le cycle Perception-Raisonnement-Action et les critères de choix d'un framework
AutoGen : le framework Microsoft pour agents conversationnels — l'autre SDK Microsoft, plus adapté aux scénarios multi-agents avec rôles
Quel est le meilleur framework agent IA en 2026 ? — comparatif détaillé SK, CrewAI, AutoGen, LangGraph selon vos contraintes
CrewAI : orchestration d'agents avec rôles — l'alternative Python quand vous avez besoin d'agents spécialisés en équipe
LangChain et LlamaIndex : guide pratique — les frameworks Python concurrents pour les pipelines RAG et agents

Semantic Kernel : guide complet du SDK IA Microsoft en Python

Semantic Kernel : guide complet du SDK IA Microsoft en Python

Introduction

Résumé rapide

Ce qu'est Semantic Kernel

Positionnement Microsoft

Architecture du SDK

Disponibilité Python

Concepts clés, installation et exemples

Installation

Configuration du Kernel

Plugins et Functions

FunctionChoiceBehavior : invocation automatique des fonctions

Mémoire et VectorStore

Agent Framework (SK 1.x)

Exemple concret : agent assistant d'email avec mémoire

Bonnes pratiques

FAQ

Articles liés

Restez informé sur les agents IA

Articles liés