Développement IA local avec Ollama et .NET

Circuits ondulés colorés avec un bouclier Ollama et des puces .NET

Développement IA local avec Ollama et .NET

Le paysage de l’IA a évolué rapidement, mais il y a une préoccupation croissante concernant l’envoi de données sensibles vers des services cloud, la gestion des coûts d’API et le maintien de la fonctionnalité sans connexion Internet. Voici Ollama, une solution qui apporte de puissants modèles de langage sur votre machine locale, parfaitement couplée à l’écosystème robuste de .NET.

Pourquoi le développement IA local est important

Confidentialité et sécurité : Vos données ne quittent jamais votre machine. Ceci est crucial pour les industries traitant des informations sensibles, des documents juridiques, des dossiers de santé ou des données commerciales propriétaires.

Contrôle des coûts : Pas de frais par token, pas de factures surprises. Une fois que vous avez téléchargé un modèle, l’inférence est gratuite au-delà de vos coûts d’électricité.

Capacité hors ligne : Créez des applications qui fonctionnent sans connexion Internet—essentiel pour le travail sur le terrain, les environnements isolés ou les régions avec une connectivité peu fiable.

Flexibilité de développement : Expérimentez librement sans vous soucier des limites de taux d’API ou des coûts pendant le développement et les tests.

Qu’est-ce qu’Ollama?

Ollama est un outil open-source qui facilite l’exécution de grands modèles de langage localement. Pensez-y comme Docker pour les modèles IA—il gère les téléchargements de modèles, gère les ressources et fournit une interface API simple.

Modèles supportés :

  • Llama - Modèles phares de Meta (Llama 3.1, 3.2, 3.3, 4 avec vision)
  • Qwen - Modèles hautement performants multilingues d’Alibaba (Qwen 3, Qwen 2.5)
  • Mistral - Modèles efficaces avec long contexte (Mistral Small, Large, Nemo)
  • DeepSeek - Modèles de raisonnement (DeepSeek-R1, DeepSeek-V3)
  • Phi - Modèles compacts de Microsoft (Phi-3, Phi-4)
  • Gemma - Modèles ouverts de Google (Gemma 3, CodeGemma)
  • CodeLlama / Devstral - Spécialisés pour la génération de code
  • Modèles spécialisés - Modèles de vision, multimodaux, de raisonnement, d’embedding
  • Et des centaines d’autres

Parcourez la bibliothèque complète sur ollama.com/library pour explorer tous les modèles disponibles, y compris les versions spécialisées pour le codage, le raisonnement, le support multilingue et les capacités de vision.

Configuration d’Ollama

Installation

Windows : Téléchargez l’installateur depuis ollama.ai/download et exécutez-le, ou utilisez winget :

winget install Ollama.Ollama

Ollama s’exécute comme un service en arrière-plan.

macOS :

brew install ollama

Linux :

curl -fsSL https://ollama.ai/install.sh | sh

Télécharger votre premier modèle

ollama pull llama3.2

Ceci télécharge le modèle Llama 3.2 (~4.7GB). Démarrez-le avec :

ollama run llama3.2

Tester l’API

Ollama expose une API REST sur http://localhost:11434. Testez-la :

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Pourquoi le ciel est-il bleu?",
  "stream": false
}'

Intégration d’Ollama avec .NET

Utilisation d’HttpClient

Pour des scénarios simples, utilisez le HttpClient intégré de .NET :

using System.Net.Http.Json;
using System.Text.Json;

public class OllamaClient
{
    private readonly HttpClient _httpClient;
    private const string BaseUrl = "http://localhost:11434";

    public OllamaClient()
    {
        _httpClient = new HttpClient { BaseAddress = new Uri(BaseUrl) };
    }

    public async Task<string> GenerateAsync(string model, string prompt)
    {
        var request = new
        {
            model,
            prompt,
            stream = false
        };

        var response = await _httpClient.PostAsJsonAsync("/api/generate", request);
        response.EnsureSuccessStatusCode();

        var result = await response.Content.ReadFromJsonAsync<OllamaResponse>();
        return result?.Response ?? string.Empty;
    }
}

public record OllamaResponse(string Response, string Model, bool Done);

Utilisation :

var client = new OllamaClient();
var answer = await client.GenerateAsync("llama3.2", "Expliquez l'injection de dépendances en C#");
Console.WriteLine(answer);

Utilisation de la bibliothèque OllamaSharp

Pour une utilisation en production, considérez OllamaSharp :

dotnet add package OllamaSharp

using OllamaSharp;

var ollama = new OllamaApiClient("http://localhost:11434", "llama3.2");

var chat = new Chat(ollama);
await foreach (var response in chat.SendAsync("Quels sont les principes SOLID?"))
{
    Console.Write(response);
}

Construire un système de Q&R documentaire

Voici un exemple pratique combinant Ollama avec le traitement de documents :

public class DocumentQAService
{
    private readonly OllamaClient _ollama;
    private readonly Dictionary<string, string> _documents = new();

    public DocumentQAService(OllamaClient ollama)
    {
        _ollama = ollama;
    }

    public void AddDocument(string id, string content)
    {
        _documents[id] = content;
    }

    public async Task<string> AskQuestionAsync(string question)
    {
        // Combiner tous les documents comme contexte
        var context = string.Join("\n\n", _documents.Values);
        
        var prompt = $"""
            Contexte:
            {context}
            
            Question: {question}
            
            Répondez uniquement en vous basant sur le contexte fourni ci-dessus.
            """;

        return await _ollama.GenerateAsync("llama3.2", prompt);
    }
}

Utilisation :

var qa = new DocumentQAService(new OllamaClient());
qa.AddDocument("politique", "Notre politique de remboursement autorise les retours dans les 30 jours...");
qa.AddDocument("livraison", "Nous expédions dans le monde entier avec DHL. La livraison prend 3-5 jours...");

var answer = await qa.AskQuestionAsync("Quelle est votre politique de remboursement?");
Console.WriteLine(answer);

Choisir le bon modèle

Différents modèles conviennent à différents besoins :

ModèleTailleMeilleur pourVitesse
Phi-414BRaisonnement rapide et codageRapide
Llama 3.21B-3BTâches rapides, chatTrès rapide
Qwen 2.57B-32BUsage général, codageMoyenne
Llama 3.18B-70BRaisonnement complexeMoyen-Lent
DeepSeek-R17B-671BRaisonnement avancéPlus lent

Pour le développement, commencez avec Qwen 2.5 7B ou Llama 3.2 3B (excellent équilibre vitesse-qualité). Pour les tâches de codage, DeepSeek-Coder ou Devstral sont des choix spécialisés.

Bonnes pratiques

1. Ingénierie des prompts

Soyez précis et fournissez du contexte :

// ❌ Vague
var result = await ollama.GenerateAsync("qwen2.5", "Écrivez du code");

// ✅ Spécifique
var result = await ollama.GenerateAsync("qwen2.5", 
    "Écrivez une méthode C# qui valide les adresses e-mail en utilisant regex. " +
    "Incluez la gestion des erreurs et les commentaires de documentation XML.");

2. Contrôle de la température

Contrôlez l’aléatoire avec la température (0.0 = déterministe, 1.0 = créatif) :

var request = new
{
    model = "qwen2.5",
    prompt = "Générez une histoire créative",
    options = new
    {
        temperature = 0.3 // Lower value = more deterministic
    }
};

3. Fenêtres de contexte

Les modèles ont des limites de tokens ou de contexte qui varient selon le modèle et sa configuration (de nombreux modèles modernes supportent de 8K jusqu’à 128K tokens, voire plus). Pour des documents plus longs, implémentez la segmentation :

public async Task<string> SummarizeLongDocument(string document)
{
    const int chunkSize = 2000; // caractères
    var chunks = SplitIntoChunks(document, chunkSize);
    var summaries = new List<string>();

    foreach (var chunk in chunks)
    {
        var summary = await _ollama.GenerateAsync("qwen2.5", 
            $"Résumez ce texte:\n{chunk}");
        summaries.Add(summary);
    }

    // Résumé final des résumés
    return await _ollama.GenerateAsync("qwen2.5",
        $"Créez un résumé final à partir de ces résumés:\n{string.Join("\n", summaries)}");
}

4. Gestion des modèles

Vérifier les modèles disponibles :

ollama list

Supprimer les modèles inutilisés pour économiser de l’espace :

ollama rm mistral

Considérations de performance

Exigences matérielles :

  • Minimum : 8GB RAM, CPU moderne
  • Recommandé : 16GB+ RAM, GPU avec support CUDA/ROCm
  • Optimal : 32GB RAM, GPU NVIDIA série RTX

Accélération GPU :

Ollama utilise automatiquement votre GPU s’il est disponible. Vérifiez avec :

ollama ps

Utilisation de la mémoire :

Surveillez avec :

# Windows
Get-Process ollama

# Linux/Mac
ps aux | grep ollama

Cas d’usage courants

1. Assistant de révision de code

var review = await ollama.GenerateAsync("devstral",
    $"Révisez ce code C# pour détecter les problèmes:\n{code}");

2. Rédaction d’e-mails

var email = await ollama.GenerateAsync("qwen2.5",
    "Rédigez un e-mail professionnel déclinant poliment une demande de réunion.");

3. Extraction de données

var extracted = await ollama.GenerateAsync("qwen2.5",
    $"Extrayez les noms, dates et montants de cette facture:\n{invoice}");

4. Traduction

var translation = await ollama.GenerateAsync("qwen2.5",
    $"Traduisez en anglais: {frenchText}");

Limitations et considérations

Qualité du modèle : Les modèles locaux peuvent ne pas égaler la qualité de GPT-4o pour les tâches complexes. Choisissez en fonction de vos besoins.

Intensif en ressources : Les modèles plus grands nécessitent beaucoup de RAM et bénéficient grandement des GPU.

Pas de connaissances Internet : Les modèles ne connaissent que les informations de leurs données d’entraînement. Ils ne peuvent pas accéder aux événements actuels ou au contenu web.

Hallucinations : Tous les LLM peuvent générer des informations plausibles mais incorrectes. Validez toujours les sorties critiques.

Prochaines étapes

  1. Commencez petit : Essayez Phi-4 ou Llama 3.2 pour les expériences initiales
  2. Construisez des prototypes : Créez des applications simples de chat ou de traitement de documents
  3. Optimisez les prompts : Expérimentez avec différentes structures de prompts
  4. Ajoutez RAG : Combinez avec des bases de données vectorielles pour un meilleur contexte
  5. Surveillez les performances : Profilez votre application sous charge

La combinaison d’Ollama et .NET ouvre des possibilités pour des applications IA axées sur la confidentialité et rentables. Que vous construisiez des outils internes, prototypiez des idées ou créiez des logiciels capables de fonctionner hors ligne, l’IA locale vous donne contrôle et flexibilité.

Explorez, expérimentez et innovez—le futur de l’IA est entre vos mains, localement.

Cet article a été créé avec l’aide de l’IA.

IA  Ollama  .NET  Apprentissage automatique  LLM  Développement local 

Suggestions de lecture :