Dot.Blog

Il existe plusieurs façons d'accéder aux IA en C#, comment choisir ? Je vous propose de comparer les trois méthodes actuellement disponibles.

Voici pour simplifier les trois voies actuelles :

• Microsoft.Extensions.AI (ME.AI) : la couche d’abstraction standard .NET pour appeler des modèles (OpenAI, Azure OpenAI, Ollama, etc.). Idéal si vous voulez un client minimal, portable, testable, DI‑friendly avec streaming, tool calling, télémétrie et cache.
  
  

• Semantic Kernel (SK) : une boîte à outils d’orchestration (prompts, mémoire, fonctions/plans) – pratique pour structurer des enchaînements, mais appelée à converger vers l’Agent Framework.

• Microsoft Agent Framework (MAF) : le successeur de SK pour construire des agents (mono ou multi‑agents), outillage MCP, hébergement et observabilité. À privilégier pour les scénarios “agentiques” modernes (mais encore largement en preview à l'heure actuelle).

Recommandation rapide que je vais développer :

• App .NET « classique » (API, desktop, worker) avec appels LLM → ME.AI.

• Chaînes/outils existants autour de SK → gardez SK, mais surveillez MAF.

• Agents, outils multiples, orchestration avancée → MAF (appuyé sur ME.AI).

Pourquoi trois options ?

On peut voir l’écosystème en couches :

[ Fournisseurs de modèles ]  OpenAI / Azure OpenAI / Mistral / Ollama / …
           │
           ▼
[ Abstraction .NET ]  Microsoft.Extensions.AI  → IChatClient, IEmbeddingGenerator, pipeline, DI
           │
           ├── (Orchestration “classique”)  Semantic Kernel  → prompts, mémoire, fonctions, plans
           └── (Agents “modernes”)          Microsoft Agent Framework → agents, outils, MCP, workflows

• ME.AI fournit l’interface commune (IChatClient, streaming, options, cache, télémétrie, tool calling…).

• SK et MAF s’appuient sur ME.AI pour ajouter respectivement orchestration et agents.

Comparaison synthétique

1) Microsoft.Extensions.AI : le standard minimal et portable

Cas d’usage

• Appeler un modèle rapidement, sans se lier à un fournisseur.

• Injecter un client dans vos services (ASP.NET, worker, desktop).

• Activer streaming, tools, cache, télémétrie par composition de middleware.

Exemple express – Appel direct

using Microsoft.Extensions.AI;

// NuGet : Microsoft.Extensions.AI + Microsoft.Extensions.AI.OpenAI
// Variable d’environnement OPENAI_API_KEY requise
IChatClient client = new OpenAI.Chat.ChatClient(
    model: "gpt-4o-mini",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
).AsIChatClient();

var response = await client.GetResponseAsync("Explique la différence entre ME.AI, SK et MAF en 3 puces.");
Console.WriteLine(response.Text);

Exemple – Injection + middleware (cache, tools, logs…)

using Microsoft.Extensions.AI;
using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();

services
    .AddChatClient(new OpenAI.Chat.ChatClient(
        model: "gpt-4o-mini",
        apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")))
    .UseDistributedCache(new MemoryDistributedCache(
        new Microsoft.Extensions.Options.OptionsWrapper<MemoryDistributedCacheOptions>(new())))
    .UseFunctionInvocation() // Active l’invocation auto de fonctions .NET décrites au modèle
    .UseLogging();           // Journalise requêtes/réponses

var provider = services.BuildServiceProvider();
var chat = provider.GetRequiredService<IChatClient>();

string GetCurrentWeather() => DateTime.UtcNow.Minute % 2 == 0 ? "Ensoleillé" : "Pluvieux";

var options = new ChatOptions {
    Tools = [AIFunctionFactory.Create((Func<string>)GetCurrentWeather)]
};

await foreach (var update in chat.GetStreamingResponseAsync(
    "Dois‑je prendre un parapluie ?", options))
{
    Console.Write(update);
}

Points forts

• API propre et testable, DI partout, portable entre fournisseurs.

• Pipeline composable : cache, télémétrie (OpenTelemetry), rate‑limiting, etc.

• Tools et MCP possibles.

Limites

• Pas de notion native d’agent, de mémoire longue, de planification → à construire vous‑même ou à confier à SK/MAF.

2) Semantic Kernel : orchestration « classique » (prompts, mémoire, fonctions)

Cas d’usage

• Vous avez déjà des prompts/fonctions SK (plugins), une mémoire, des plans.

• Vous voulez composer prompts + fonctions + stockage, avec une API haut niveau.

Bien entendu pour tout savoir (ou presque) sur Semantic Kernel je renvoie le lecteur à ma série de 11 vidéos publiées en septembre "Initiation à Semantic Kernel en C#" sur YouTube.
https://youtube.com/playlist?list=PL6jdAGQhDiX27YTwu2LzdZwJSAEpnxRGE&si=NrtkZsPIvsRjGHwj

Exemple – Chat complet minimal avec SK

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;

var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion(
    modelId: "gpt-4o-mini",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);
var kernel = builder.Build();

var chat = kernel.GetRequiredService<IChatCompletionService>();
var history = new ChatHistory();

history.AddSystemMessage("Tu es un assistant concis et technique.");
history.AddUserMessage("Explique la valeur de SK face à ME.AI.");

var result = await chat.GetChatMessageContentAsync(history, kernel: kernel);
Console.WriteLine(result.Content);

Points forts

• Connecteurs (OpenAI, Azure OpenAI, Ollama, Mistral, etc.).

• Objets de haut niveau : ChatHistory, fonctions, plans, mémoire.

À connaître en 2025

• Les scénarios agents et workflows modernes migrent vers Microsoft Agent Framework. SK reste utile là où il est déjà en place et pour des chaînes simples.

3) Microsoft Agent Framework : le successeur orienté « agents »

Cas d’usage

• Construire rapidement un agent (ou plusieurs) avec instructions, outils, MCP, observabilité et hébergement.

• Faire évoluer une POC SK vers un système agentique plus complet.

Exemple – Premier agent (Azure/OpenAI)

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI; // NuGet: Microsoft.Agents.AI.OpenAI (préversion au moment d’écrire)

var agent = new AzureOpenAIClient(
    new Uri("https://your-resource.openai.azure.com/"),
    new AzureCliCredential())
  .GetChatClient("gpt-4o-mini")
  .CreateAIAgent(instructions: "Tu es excellent pour raconter des blagues.");

Console.WriteLine(await agent.RunAsync("Raconte une blague de pirate."));

Remarque : il est possible d’utiliser également un ApiKeyCredential ou d’autres backends. L’agent s’appuie en interne sur Microsoft.Extensions.AI.

Points forts

• Modèle “agent” prêt à l’emploi (mono/multi‑agents, rôles, outils, MCP).

• Chemin officiel de Microsoft pour les scénarios agentiques post‑SK.

• Observabilité et hébergement facilités.

Limites

• Jeune (cadre en évolution). Validez les versions et les packages au moment du build.

Schémas d’architecture (vue d’ensemble)

A. App .NET « classique » (ME.AI)

UI / API / Service
   │         
   ▼         
IChatClient (ME.AI)  ──►  Impl. fournisseur (OpenAI, Azure OpenAI, Ollama…)
   │
   ├─ (optionnel) Cache distribué / Télémétrie / Tools / Rate‑limit
   └─ (optionnel) MCP client

B. Orchestration avec SK

UI / API
   │
   ▼
Semantic Kernel (prompts, mémoire, fonctions, plans)
   │
   └─ IChatClient / Connecteurs (OpenAI/Azure/Ollama…)

C. Système agentique avec MAF

UI / API / Worker
   │
   ▼
Microsoft Agent Framework (agents, outils, MCP, observabilité)
   │
   └─ IChatClient (ME.AI)  →  fournisseur(s) de modèles

Foire aux questions express

Puis‑je combiner ? Oui. ME.AI est la brique de base. Vous pouvez l’utiliser seul, ou via SK / MAF.

Et le RAG local ? ME.AI expose IEmbeddingGenerator ; SK possède des connecteurs ; MAF se concentre sur l’agent. Mon contenu à venir montrera un pipeline RAG local complet (Qdrant, API locale Kestrel, UI .NET) et un exemple Agent Framework.

Etat de maturité ? ME.AI est le standard. SK reste utile mais l’orientation agents passe à MAF dont les concepts sont proches de SK mais avec une écriture simplifiée (par exemple la possibilité de fixer les instructions système à la création de l'Agent, sans les répéter à chaque Prompt).

Références utiles

Documentation officielle :

• • Microsoft.Extensions.AI : IChatClient, pipelines, tools, DI, cache, télémétrie.

  • Semantic Kernel : ajout d’un service de chat, ChatHistory, streaming.

  • Microsoft Agent Framework : Overview & Quick‑Start.

Conclusion

Les IA ont fait une entrée fracassante dans le monde avec ChatGPT puis d'autres LLM. On parle d'IA partout, on en voit partout, l'avenir est IA. Certes, mais il faut des outils pour développer des logiciels qui utilisent avec intelligence ces IA ! Or avant de développer des logiciels bien conçus encore faut-il disposer des bons outils, et eux aussi doivent prendre le temps de la maturation avant de se standardiser.
Microsoft a fourni un travail de base essentiel avec Extensions.AI, puis un travail encore plus énorme avec Semantic Kernel qui est devenu de plus en plus sophistiqué. La sagesse s'est imposée : plutôt que de continuer à faire enfler SK dans de nombreuses directions, mieux valait reprendre les bases, Extensions.AI et adopter le meilleur de SK en le simplifiant, c'est Agent Framework, plus direct, plus puissant à certans égards, mais toujours basés sur Extensions.AI. SK et Agent Framework sont d'ailleurs produit par la même équipe de développement.

• ME.AI : standard unifié pour accéder aux modèles.

• SK : orchestration historique, utile si vous avez déjà des artefacts SK.

• MAF : futur orienté agents, workflows multi‑agents et intégration MCP.

👉 Dans mes prochains contenus : RAG local complet (sans cloud), puis Agent Framework en pratique (outils, workflows, observabilité).

Stay Tuned !