GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro, Llama 3, Mistral — le marché des LLMs est dense, les benchmarks se contredisent, et les annonces de “nouveau modèle state-of-the-art” se succèdent tous les 2-3 mois. Comment choisir le bon pour ton projet .NET sans passer des semaines à comparer ?

Dans cette leçon, on va passer en revue les grands acteurs de façon pragmatique — pas depuis les benchmarks marketing, mais depuis ce qui compte pour un développeur qui doit mettre quelque chose en production.

OpenAI — GPT-4o et la famille GPT

GPT-4o — le standard de l’industrie

GPT-4o (“o” pour “omni”) est le modèle flagship d’OpenAI depuis mai 2024. Il traite nativement texte, images, et audio dans un seul modèle. C’est le modèle le plus utilisé en production dans le monde, ce qui a des avantages concrets :

  • Écosystème le plus mature : plus de bibliothèques, tutoriels, et patterns documentés
  • Azure OpenAI Service : disponible directement dans Azure avec RGPD, SLA enterprise, et une région France (France Central)
  • Outils les plus avancés : function calling, Assistants API, fine-tuning, batch processing
  • Comportement le plus prévisible : le plus de retours d’expérience production disponibles

GPT-4o mini — le meilleur rapport qualité/prix

GPT-4o mini est 16x moins cher que GPT-4o pour des performances qui atteignent 80-90% de GPT-4o sur les tâches courantes. Pour la majorité des cas d’usage en production (chatbots, extraction d’informations, classification), GPT-4o mini est le bon choix par défaut.

o1 et o3 — les modèles de raisonnement

Les modèles o1 et o3 utilisent une technique appelée “chain-of-thought étendu” — avant de répondre, le modèle “réfléchit” pendant plusieurs secondes à minutes en générant un raisonnement interne non visible. Résultats :

  • Excellents sur les problèmes de mathématiques, logique, et code complexe
  • Latence très élevée (10-120 secondes de réflexion)
  • Très coûteux (o1 est ~6x plus cher que GPT-4o)
  • À réserver aux tâches réellement complexes : audit de code, résolution de bugs complexes, algorithmes

Anthropic — Claude 3.5 et 3.7

Anthropic se positionne explicitement sur la sécurité et la fiabilité. Claude a quelques caractéristiques distinctives qui le rendent particulièrement intéressant pour certains cas d’usage :

Points forts de Claude

  • 200 000 tokens de contexte — 56% de plus que GPT-4o. Excellent pour analyser des codebases entières, des contrats longs, ou des conversations très étendues.
  • Meilleur pour le code complexe — Sur plusieurs benchmarks indépendants, Claude 3.5 Sonnet surpasse GPT-4o sur la génération de code, notamment pour les refactorings complexes et l’explication de code legacy.
  • Comportement plus prévisible sur les instructions — Claude suit plus fidèlement des instructions complexes et multi-étapes. Moins de “dérive” par rapport au system prompt sur de longues conversations.
  • Rédaction longue de haute qualité — Pour générer des documents longs (rapports, documentation technique, articles), Claude produit souvent une cohérence supérieure sur toute la longueur.

Limitations de Claude

  • Pas de service Azure natif (disponible via AWS Bedrock ou API directe Anthropic)
  • Écosystème de tools moins développé que OpenAI
  • Plus cher que GPT-4o (Claude 3.5 Sonnet : $3/M tokens input vs $2.50 pour GPT-4o)
// Claude via API Anthropic — SDK officiel .NET
// dotnet add package Anthropic.SDK

using Anthropic.SDK;
using Anthropic.SDK.Messaging;

var client = new AnthropicClient(
    new APIAuthentication(Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY")!)
);

var messages = new List<Message>
{
    new Message { Role = RoleType.User, Content = "Explique le pattern CQRS en .NET avec un exemple concret." }
};

var parameters = new MessageParameters
{
    Model   = AnthropicModels.Claude35Sonnet,
    MaxTokens = 2000,
    System  = "Tu es un architecte .NET senior. Tes réponses incluent toujours du code C# complet.",
    Messages = messages
};

var response = await client.Messages.GetClaudeMessageAsync(parameters);
Console.WriteLine(response.Content[0].Text);

Google — Gemini 1.5 et 2.0

Google Gemini se distingue principalement sur deux axes :

Fenêtre de contexte exceptionnelle

Gemini 1.5 Pro accepte jusqu’à 1 million de tokens — l’équivalent de 750 000 mots ou 3 000 pages. C’est une rupture qualitative qui ouvre des cas d’usage impossibles avec les autres modèles :

  • Analyser une codebase entière de plusieurs dizaines de milliers de lignes en une seule requête
  • Traiter une vidéo d’une heure entière (images + audio + texte)
  • Analyser des datasets complets de logs ou d’événements

Multimodalité native

Gemini a été conçu dès le départ pour être multimodal — pas ajouté après coup comme pour GPT-4V. Il gère nativement texte, images, audio, vidéo, et code. Si ton app doit analyser des flux vidéo ou des contenus riches, Gemini est souvent le meilleur choix.

Gemini Flash — le moins cher du marché

Gemini 1.5 Flash est à $0.075 per million de tokens en entrée — 3x moins cher que GPT-4o mini, 33x moins cher que GPT-4o. Pour des applications à très haut volume où la qualité “bonne mais pas parfaite” est acceptable, Gemini Flash peut changer l’économie d’un projet.

Meta — Llama 3.1 et 3.2 (open source)

Llama est la famille de modèles open source de Meta. Ce qui le distingue fondamentalement des autres : tu peux le faire tourner sur ta propre infrastructure.

Cas d’usage où Llama est le bon choix :

  • Données ultra-sensibles : médical (HIPAA), financier, militaire, juridique — les données ne quittent jamais ton infrastructure
  • Réglementations strictes : RGPD avec exigence de localisation des données, secteurs régulés
  • Volume très élevé : au-delà d’un certain volume, le coût des GPU devient inférieur aux API fees
  • Fine-tuning custom : tu peux entraîner Llama sur tes propres données propriétaires sans les partager avec OpenAI ou Anthropic
// Llama via Ollama (local) — même interface qu'OpenAI
// 1. Installer Ollama : https://ollama.ai
// 2. Dans le terminal : ollama pull llama3.1

// L'API Ollama est compatible avec l'interface OpenAI !
using OpenAI;
using OpenAI.Chat;

// Pointer vers Ollama local au lieu d'OpenAI
var client = new ChatClient(
    model: "llama3.1",
    credential: new ApiKeyCredential("ollama"),  // n'importe quoi
    options: new OpenAIClientOptions
    {
        Endpoint = new Uri("http://localhost:11434/v1")
    }
);

var messages = new List<ChatMessage>
{
    ChatMessage.CreateSystemMessage("Tu es un assistant .NET expert."),
    ChatMessage.CreateUserMessage("Qu'est-ce qu'un middleware ASP.NET Core ?")
};

// Même code qu'avec GPT — zéro modification
var response = await client.CompleteChatAsync(messages);
Console.WriteLine(response.Value.Content[0].Text);

// Pour switcher vers OpenAI : changer l'Endpoint et la clé — c'est tout.

Le tableau de décision final

BesoinModèle recommandéRaison
Démarrer un projet .NETGPT-4o miniLe plus documenté, SDK .NET officiel, Azure disponible
Chatbot de support clientGPT-4o miniRapide, économique, très bon sur les conversations courantes
Génération et review de codeClaude 3.5 SonnetMeilleur benchmark sur le code complexe
Analyse de documents longs (>100 pages)Claude 3.5 Sonnet200k tokens de contexte
Raisonnement complexe / debug algorithmiqueo1 ou o3Chain-of-thought étendu, meilleur sur les problèmes difficiles
Analyse de vidéos ou rich mediaGemini 1.5 ProMultimodal natif, 1M tokens
Volume très élevé, budget serréGemini FlashLe moins cher du marché
Données sensibles / on-premise obligatoireLlama 3.1 70BOpen source, auto-hébergeable, aucune donnée envoyée
Enterprise Azure, compliance françaiseAzure OpenAI (GPT-4o)SLA, région France, RGPD natif

Ma recommandation pratique pour commencer

Pour un développeur .NET qui commence avec les LLMs, voici la progression que je recommande :

  1. Mois 1 : OpenAI API directe avec GPT-4o mini. Apprend les patterns fondamentaux (streaming, function calling, gestion du contexte) sans te préoccuper de l’infrastructure.
  2. Mois 2-3 : Migre vers Azure OpenAI Service si tu es dans un contexte enterprise (RGPD, SLA, intégration Azure AD). Le code change très peu — juste l’endpoint et l’authentification.
  3. Selon les besoins : Ajoute Claude pour les tâches de code/documents longs, Gemini pour le multimodal, Llama pour les données sensibles. L’avantage : les APIs sont suffisamment similaires pour créer une couche d’abstraction qui te permet de switcher facilement.
// Interface commune pour abstraire le choix du modèle
public interface ILLMProvider
{
    Task<string> CompleteAsync(string systemPrompt, string userMessage);
    Task StreamAsync(string systemPrompt, string userMessage, Action<string> onChunk);
}

// Implémentation OpenAI (GPT-4o / GPT-4o mini / Azure OpenAI)
public class OpenAIProvider : ILLMProvider
{
    private readonly ChatClient _client;

    public OpenAIProvider(string apiKey, string model = "gpt-4o-mini")
        => _client = new ChatClient(model, apiKey);

    public async Task<string> CompleteAsync(string systemPrompt, string userMessage)
    {
        var response = await _client.CompleteChatAsync(new List<ChatMessage>
        {
            ChatMessage.CreateSystemMessage(systemPrompt),
            ChatMessage.CreateUserMessage(userMessage)
        });
        return response.Value.Content[0].Text;
    }

    public async Task StreamAsync(string systemPrompt, string userMessage, Action<string> onChunk)
    {
        await foreach (var update in _client.CompleteChatStreamingAsync(new List<ChatMessage>
        {
            ChatMessage.CreateSystemMessage(systemPrompt),
            ChatMessage.CreateUserMessage(userMessage)
        }))
        {
            foreach (var part in update.ContentUpdate)
                onChunk(part.Text);
        }
    }
}

// Injection de dépendance — tu changes de provider sans toucher au reste du code
services.AddSingleton<ILLMProvider>(_ => new OpenAIProvider(
    apiKey: configuration["OpenAI:ApiKey"]!,
    model:  configuration["OpenAI:Model"] ?? "gpt-4o-mini"
));

Exercice pratique

Implémente l’interface ILLMProvider avec au minimum deux providers (OpenAI et Ollama/Llama local). Puis crée un benchmark simple qui envoie les mêmes 5 prompts aux deux providers et compare :

  • La latence de réponse
  • La qualité subjective de la réponse (selon toi)
  • Le nombre de tokens utilisés (si disponible)

Ce benchmark personnel est plus utile que n’importe quel classement en ligne — parce qu’il teste exactement tes cas d’usage, pas des benchmarks génériques qui peuvent ne pas correspondre à ton domaine.

Récapitulatif

  • GPT-4o mini : le point de départ recommandé. Meilleur écosystème, Azure disponible, économique.
  • Claude 3.5 Sonnet : code complexe, documents longs, 200k contexte.
  • Gemini 1.5 Pro/Flash : multimodal natif, 1M contexte, le moins cher.
  • o1/o3 : raisonnement complexe uniquement — lent et coûteux.
  • Llama 3.1 : données sensibles, on-premise, volume extrême.
  • Crée une interface d’abstraction dès le début — switcher de modèle doit être une config, pas un refactoring.

Module 1 terminé ! Tu as maintenant une compréhension solide de ce qu’est l’IA, des différences entre ML/DL/LLMs, du mécanisme de prédiction token par token, de la gestion du contexte, et des différents modèles disponibles. Dans le Module 2, on passe à la pratique du prompt engineering — comment parler aux LLMs pour obtenir des résultats fiables et reproductibles dans tes applications .NET.