Installer Ollama et obtenir une IA locale

Dans un de mes derniers articles à propos de mon composant résumé TL;DR, j'ai écrit un script Python pour consommer l'API Gemini et boum, après quelques requêtes à peine, j'ai reçu une erreur de quota maximum dépassé.

Et si on pouvait régler ça gratuitement ? Comment ? Tout simplement en installant un LLM en local, sur notre machine. Fini les quotas.

Essayez dans votre terminal​

Une fois Ollama lancé et un modèle téléchargé (voir la section Installation plus bas), la commande est ollama run <model_name> :

$ docker exec -it ollama ollama run llama3.1:8b▋

Vous pouvez maintenant poser n'importe quelle question, par exemple une comparaison entre Quarto et Docusaurus :

Ou demander une blague :

Tapez /bye pour quitter.

Dois-je parler anglais avec le modèle ?​

En fait, non — comme pour une page web, vous pouvez utiliser votre propre langue. Dans l'exemple ci-dessous, vous verrez aussi une autre façon de poser une question : au lieu de passer par un terminal interactif, vous pouvez taper votre question directement sur la ligne de commande.

Avez-vous besoin d'un LLM local ?​

La raison la plus importante est sans doute la confidentialité : l'avoir en local, sur votre machine, signifie que vos documents restent chez vous. Vous ne partagerez pas votre codebase, par exemple, avec des sociétés d'IA. C'est exactement pour cette raison que j'aimais Tabnine, qui fonctionne aussi hors ligne — Ollama pousse simplement l'idée beaucoup plus loin.

Pensez aussi à l'automatisation : vous pourrez exécuter des scripts d'automatisation sans craindre d'atteindre un quota. Et pas de facture non plus : comme tout tourne sur votre machine, c'est entièrement gratuit.

Installer et lancer Ollama​

Vous vous en doutez, en amoureux de Docker, je n'installerai pas Ollama à la main.

Créons le fichier compose.yaml sur votre disque. J'utilise quelques containers Docker tous les jours et je range leurs fichiers de configuration dans un dossier ~/tools ; faisons pareil ici.

Lancez mkdir ~/tools/ollama && cd $_ puis créez un compose.yaml avec ce contenu :

Toujours dans le dossier ~/tools/ollama, lancez simplement docker compose up --detach pour télécharger ollama et le faire tourner dans un container Docker.

Télécharger un modèle LLM​

D'abord, réfléchissez à votre cas d'usage. Vous voudrez très probablement de la vitesse et de la précision.

Pour la vitesse, prenez un « petit » LLM comme llama3.1:8b. Un exemple : vous comptez utiliser une extension VSCode et vous avez besoin de rapidité pour l'autocomplétion.

Pour la précision, vous accepterez peut-être d'attendre un peu plus longtemps pour obtenir de meilleurs résultats.

Commencez par regarder combien de RAM libre vous avez.

$ free -h
               total        used        free      shared  buff/cache       available
Mem:            15Gi       5.4Gi       2.4Gi       9.7Mi       7.8Gi       9.9Gi
Swap:          4.0Gi        11Mi       4.0Gi

Regardez la dernière colonne available. J'ai environ 10 Go libres, je peux donc facilement choisir un modèle d'environ 4,7 Go, comme llama3.1:8b.

Ouvrez un nouveau terminal et lancez cette commande :

$ docker exec -it ollama ollama pull llama3.1:8b▋

Si vous relancez free -h, regardez à nouveau la colonne Available. J'avais ~9,9 Go avant, j'ai maintenant ~5,5 Go.

Besoin de plus de puissance ?​

Il existe énormément de modèles ; regardez le suffixe à la fin de llama3.1:8b : 8b signifie 8 milliards de paramètres. Plus il y en a, plus le modèle a de connaissances, mais cela a un prix : la taille.

Si vous avez plus de 32 Go de RAM, vous pouvez sans doute aussi utiliser gemma2:27b (27 milliards de paramètres, environ 17 Go), mixtral:8x7b (environ 26 Go) ou llama3:70b (70 milliards de paramètres, ~45 Go).

Plus le nombre de paramètres est élevé, meilleurs sont les résultats — mais plus la réponse est lente. À vous de déterminer, pour votre propre cas d'usage (votre matériel, votre GPU, vos besoins...), un ou deux LLM que vous utiliserez.

Par exemple, un modèle très rapide (donc petit) pour les interactions courtes — vous ne voulez pas attendre 30 secondes une réponse — et un plus puissant pour les tâches lourdes comme le refactoring de code ou la génération d'une codebase.

Que signifie 8x7b ?​

Si vous regardez mixtral, vous remarquerez le suffixe 8x7b. Cela indique que le modèle utilise une architecture Mixture of Experts (MoE) : il est composé de 8 réseaux de neurones experts distincts, chacun avec 7 milliards de paramètres.

Quand vous utilisez ce type de modèle, un routeur intégré analyse d'abord votre prompt pour déterminer quels experts sont les mieux placés pour répondre.

Prenons un exemple : imaginez que vous demandiez à Mixtral de générer une fonction Python. Le routeur traite d'abord le contexte de votre question. Puis il active de façon transparente uniquement les experts les plus pertinents pour cette tâche (en général deux sur huit) afin de produire la meilleure réponse possible.

Parce qu'il utilise ses experts de manière sélective, mixtral est un modèle incroyablement polyvalent et très efficace — à condition que votre machine ait assez de RAM pour charger l'ensemble en mémoire !

Obtenir la liste des modèles​

Si vous voulez récupérer les modèles déjà installés :

$ docker exec -it ollama ollama list▋

La liste complète des modèles existants est en ligne : https://ollama.com/library

Utiliser une interface web​

Vous pouvez installer une interface web pour dialoguer avec Ollama ; la plus utilisée est Open WebUI.

Éditons notre fichier compose.yaml et ajoutons un nouveau service :

Lancez docker compose up --detach pour télécharger l'image open-webui (~1,7 Go) et créer le container.

Maintenant, rendez-vous simplement sur http://localhost:4000 et vous aurez votre interface ; vous pouvez commencer à interagir avec votre LLM local.

Regardez en haut à gauche : vous y voyez la liste des modèles installés.

Utiliser une extension VSCode​

Si vous voulez ajouter de l'IA dans VSCode, vous pouvez installer Continue - open-source AI agent.

Continue a besoin d'un fichier de configuration dans votre dossier utilisateur Windows — pas du côté WSL, du moins lors de mes tests d'origine ; à revérifier sur les versions actuelles si cela ne correspond pas à ce que vous observez.

Ouvrez un terminal Powershell, lancez cd ~/.continue ; notepad config.yaml et collez le contenu de ce fichier :

Redémarrez VSCode ou, dans le panneau Continue, trouvez l'option Local config et sélectionnez Refresh.

Quand vous voyez le nom de votre modèle dans la liste des modèles chargés, Continue est prêt à traiter votre première question.

À partir de là, vous pouvez utiliser Continue pour poser des questions sur votre codebase, générer des tests unitaires, refactorer du code, etc.

La vitesse dépendra évidemment du modèle choisi et de votre matériel.

Utiliser l'autocomplétion​

Quand vous tapez du texte dans VSCode, vous voulez une autocomplétion immédiate, pas attendre une seconde ou plus.

Pour cela, il vous faut un modèle plus rapide ; prenons qwen2.5-coder:1.5b (1,5 milliard de paramètres, environ 1 Go).

$ docker exec -it ollama ollama pull qwen2.5-coder:1.5b▋

Mettez à jour votre fichier .continue/config.yaml (côté Windows) avec ce nouveau contenu :

Maintenant que j'ai ajouté le modèle qwen2.5-coder:1.5b dans mon fichier de config, créons un fichier calculate.sh avec ce contenu :

#!/bin/bash

function?

... et rien de plus.

Après une seconde à peine, VSCode propose de compléter la fonction avec le bon code :

J'ai accepté la suggestion et tapé function main ; là encore, après une seconde, le reste du code a été autocomplété.

Puis j'ai tapé function help, accepté la proposition, et enfin accepté les dernières lignes du script.

En moins de 5 secondes, j'ai donc obtenu un script complet avec le bon code et les bons commentaires. Le tout sans écrire une seule ligne de code, juste en acceptant les suggestions du LLM.

Et ça marche du premier coup !

$ chmod +x ./calculate.sh

$ ./calculate.sh
Usage: ./calculate.sh \<num1\> \<num2\> \<operator\>
Example: ./calculate.sh 5 3 +

❯ ./calculate.sh 5 3 -
5 - 3 = 2
▋

Utiliser un LLM plus puissant selon vos attentes​

Si vous avez un CPU et/ou un GPU puissant avec 24 Go ou plus, vous pouvez ajouter un modèle plus costaud comme qwen3-coder:30b :

$ docker exec -it ollama ollama pull qwen3-coder:30b▋

Ce modèle est nettement plus précis que l'assistant rapide et — grâce à l'architecture Mixture-of-Experts — reste raisonnablement véloce malgré sa taille. Gardez-le pour les tâches d'analyse de code intensives : refactoring, génération de tests unitaires complexes, etc.

Voici le test d'origine, où je demandais un refactoring à gemma2:27b — c'était vraiment lent, même sur ma machine (i9 - 64 Go) :

Et l'autocomplétion appliquée au readme.md :

[wsl2]

# Limits RAM to leave 12GB for Windows
memory=20GB?

# (Optional) Adds some dedicated swap space for WSL
swap=8GB?

# Mirror Windows network interfaces to WSL for seamless localhost access
networkingMode=mirrored?

# Automatically shrink the WSL virtual disk when files are deleted to free up space
sparseVhd=true?

[experimental]

# Enables automatic RAM reclamation so, Windows can reclaim it
autoMemoryReclaim=gradual?