Microsoft.Extensions.AI : une abstraction unifiée pour l'IA générative en .NET

Microsoft.Extensions.AI est une bibliothèque qui fournit des abstractions standardisées pour intégrer des services d'IA générative (chat, embeddings, génération d'images) dans vos applications .NET. Elle suit les mêmes patterns d'injection de dépendances et de middleware que vous connaissez déjà dans l'écosystème .NET.

Cas d'usage principaux :

• Intégrer des modèles de chat (OpenAI, Azure OpenAI, etc.) avec une API unifiée
• Générer des embeddings pour la recherche sémantique ou le RAG
• Créer des images à partir de prompts textuels
• Ajouter de l'observabilité (OpenTelemetry), du caching et du rate limiting
• Changer de fournisseur d'IA sans réécrire votre code

Microsoft.Extensions.AI vous donne des interfaces standardisées (IChatClient, IEmbeddingGenerator, IImageGenerator) et des composants middleware pour enrichir vos pipelines d'IA avec de la résilience, du logging et du caching.

Les packages

La bibliothèque est divisée en deux packages principaux :

Microsoft.Extensions.AI.Abstractions

Contient les interfaces de base (IChatClient, IEmbeddingGenerator, IImageGenerator). Les bibliothèques qui fournissent des clients d'IA référencent généralement ce package uniquement.

Microsoft.Extensions.AI

Package principal qui inclut les abstractions + les utilitaires de haut niveau (middleware, builder patterns, injection de dépendances). C'est ce package que vous référencez dans vos applications.

Installation

# Package principal
dotnet add package Microsoft.Extensions.AI

# Ou seulement les abstractions (pour les bibliothèques)
dotnet add package Microsoft.Extensions.AI.Abstractions

Les interfaces principales

IChatClient

Interface pour les modèles de chat (LLM). Supporte les conversations multi-tours, le contenu multimodal (texte, images, audio) et le streaming.

• Envoi/réception de messages
• Streaming de réponses
• Function calling (outils)
• Sortie structurée

IEmbeddingGenerator<TInput, TEmbedding>

Génère des embeddings (vecteurs) à partir d'entrées textuelles ou autres. Utile pour la recherche sémantique, le clustering, ou les systèmes RAG.

IImageGenerator (expérimental)

Génère des images à partir de prompts textuels. Support de la configuration (taille, format) et composition avec middleware.

Exemples concrets

Chat basique avec IChatClient

Dans cet exemple, IChatClient est injecté via DI et utilisé pour envoyer un message simple.

public class ChatService
{
    private readonly IChatClient _chatClient;

    public ChatService(IChatClient chatClient)
    {
        _chatClient = chatClient;
    }

    public async Task<string> GetResponseAsync(string userMessage)
    {
        var response = await _chatClient.CompleteAsync(userMessage);
        return response.Message.Text;
    }
}

Streaming de réponses

Pour les réponses longues, utilisez CompleteStreamingAsync pour recevoir les tokens au fur et à mesure.

await foreach (var update in _chatClient.CompleteStreamingAsync(messages))
{
    Console.Write(update.Text);
}

Middleware : OpenTelemetry + Caching

Ajoutez facilement de l'observabilité et du caching à vos pipelines :

services.AddChatClient(builder => builder
    .Use(OpenAIChatClient("gpt-4"))
    .UseOpenTelemetry(loggerFactory)
    .UseDistributedCache());

Le middleware s'applique automatiquement à tous les appels IChatClient. Vous pouvez enchaîner plusieurs middlewares (logging, rate limiting, retry, etc.).

Génération d'embeddings

Utilisez IEmbeddingGenerator pour créer des vecteurs à partir de textes.

var generator = new OpenAIEmbeddingGenerator(apiKey, "text-embedding-3-small");
var embeddings = await generator.GenerateAsync(new[] { "Hello world", "AI is amazing" });

foreach (var embedding in embeddings)
{
    Console.WriteLine($"Vector length: {embedding.Vector.Length}");
}

Avantages de Microsoft.Extensions.AI

• Portabilité: Changez de fournisseur (OpenAI → Azure OpenAI → autre) sans toucher à votre logique métier.
• Testabilité: Mockez facilement IChatClient ou IEmbeddingGenerator dans vos tests unitaires.
• Middleware ecosystem: Profitez de l'écosystème .NET : OpenTelemetry, caching, rate limiting, resilience.
• Injection de dépendances: Intégration native avec IServiceCollection et les patterns familiers .NET.
• API consistante: Une seule API pour tous vos besoins d'IA générative (chat, embeddings, images).

Bonnes pratiques

• Utilisez les abstractions dans votre code métier: Ne dépendez pas directement d'un SDK spécifique (ex: SDK OpenAI). Cela facilite les tests et la migration.
• Ajoutez de l'observabilité dès le début: Utilisez UseOpenTelemetry() pour suivre les coûts, latences et erreurs de vos appels d'IA.
• Activez le caching pour les requêtes répétées: Réduisez les coûts et la latence en cachant les réponses identiques.
• Composez avec resilience: Combinez avec Microsoft.Extensions.Resilience pour ajouter retry, circuit breaker, etc.
• Séparez configuration et logique: Configurez vos clients dans Startup/Program.cs, injectez-les via DI.

Ressources

• Documentation officielle Microsoft
• Repository d'exemples (dotnet/ai-samples)
• Exemple end-to-end (eShopSupport)