Faire tourner une IA en local sur son ordinateur : le tutoriel pas à pas

Faire tourner une IA en local, c’est télécharger un modèle à poids ouverts et l’exécuter sur votre propre ordinateur, sans envoyer vos textes à un service en ligne. Avec un outil comme Ollama ou llama.cpp, l’installation prend quelques commandes ; le vrai choix porte sur la taille du modèle que votre machine peut supporter.

Ce que veut dire « IA en local »

Un grand modèle de langage est un gros fichier de nombres, ses poids. Quand l’éditeur les publie, on parle de modèle à poids ouverts : vous pouvez les télécharger et faire le calcul vous-même. Ce calcul, qui produit la réponse, s’appelle l’inférence.

Trois raisons poussent à le faire chez soi :

• la confidentialité : vos documents ne quittent pas la machine ;
• le coût : pas de facture au token, seulement le matériel et l’électricité ;
• l’autonomie : le modèle fonctionne hors connexion et ne change pas sans votre accord.

La contrepartie est réelle : moins de puissance que les meilleurs modèles en ligne, et du travail d’installation. Ce tutoriel vise un premier résultat concret : un modèle qui répond dans votre terminal, puis à vos propres programmes.

Prérequis : ce dont votre machine a besoin

Avant d’installer quoi que ce soit, vérifiez trois choses.

1. Le système. Selon la documentation d’Ollama consultée le 22 octobre 2026, il faut Windows 10 22H2 ou plus récent, ou macOS Sonoma (version 14) ou plus récent. Sur Mac, les puces Apple M utilisent processeur et carte graphique ; les Mac Intel tournent sur le processeur seulement. Linux est pris en charge aussi.

2. La mémoire. C’est le critère décisif. Pour aller vite, le modèle doit tenir dans la VRAM, la mémoire de la carte graphique (GPU). À défaut, il peut tourner en mémoire vive, plus lentement. La taille d’un modèle dépend de son nombre de paramètres et de sa quantification, c’est-à-dire la précision avec laquelle chaque poids est stocké. Les fichiers au format GGUF, utilisés par ces deux outils, sont le plus souvent quantifiés autour de 4 bits.

3. Le disque. La documentation Windows d’Ollama demande au moins 4 Go pour le logiciel, plus la place des modèles.

Voici quelques ordres de grandeur relevés sur la bibliothèque officielle d’Ollama le 22 octobre 2026 (taille de téléchargement, selon la variante) :

Modèle (étiquette Ollama)	Taille indiquée	Pour quelle machine ?
qwen3.5:4b	3,3 à 4,0 Go	Portable récent, même sans carte graphique dédiée
qwen3.5:9b	6,6 à 7,6 Go	Carte graphique ou Mac avec une mémoire confortable
gemma4:e4b	6,6 à 9,5 Go	Idem
gemma4:26b	16 à 19 Go	Machine bien équipée
qwen3.5:27b	17 à 20 Go	Machine bien équipée
gemma4:31b	19 à 20 Go	Machine bien équipée

La colonne de droite est notre lecture, pas une exigence officielle. Prévoyez toujours une marge au-delà de la taille du fichier : le modèle a besoin de mémoire de travail pour le contexte de la conversation.

Choisir un modèle à poids ouverts

Les fabricants publient de plus en plus de modèles ouverts, de toutes tailles. Le tableau ci-dessous reprend quelques modèles adaptés au local, avec les données du site :

Modèle	Éditeur	Sortie	Contexte (tokens)	Entrée ($/M tokens)	Sortie ($/M tokens)	Poids ouverts
Gemma 4 31B IT	Google DeepMind	2 avril 2026	262 k	0,14 $US	0,40 $US	Oui
Gemma 4 26B A4B IT	Google DeepMind	2 avril 2026	262 k	0,10 $US	0,34 $US	Oui
Qwen3.6 27B	Alibaba Cloud (Qwen)	22 avril 2026	262 k	0,33 $US	2,7 $US	Oui
Qwen3.6 35B-A3B	Alibaba Cloud (Qwen)	17 avril 2026	262 k	0,17 $US	1 $US	Oui
Ministral 3 8B 2512	Mistral AI	2 décembre 2025	262 k	0,15 $US	0,15 $US	Oui
Granite 4.2 8B	IBM (Granite)	25 août 2026	131 k	0,06 $US	0,25 $US	Oui

Les prix affichés sont ceux des hébergeurs qui proposent ces modèles par API : en local, vous ne payez pas au token. Deux familles reviennent souvent dans les outils grand public : Gemma, de Google DeepMind, dont la fiche Gemma 4 31B IT détaille la version la plus grande, et Qwen, d’Alibaba. Les modèles notés « A4B » ou « A3B » sont des mélanges d’experts : seule une partie des poids travaille à chaque mot, ce qui accélère le calcul, mais tous les poids doivent quand même tenir en mémoire.

Pour situer leur niveau, voici l’indice du classement Epoch AI relevé le 22 octobre 2026, qui combine plusieurs tests exigeants, avec un modèle fermé de tête comme repère :

Indice de capacité (sur 100)

• Claude Opus 5.595,9
• Kimi K2.684,4
• Qwen3.6 27B72,2
• Qwen3.6 35B-A3B55,3
• Qwen3.5 9B49,6

Kimi K2.6 a des poids ouverts, mais sa taille le réserve à des serveurs. Les modèles qui tiennent sur un ordinateur personnel sont nettement plus bas. Toute la liste est sur notre page modèles open source, avec leur licence.

Étape 1 : installer Ollama

Ollama est la voie la plus simple : un programme qui télécharge les modèles, les garde en mémoire et les sert à vos applications. Les commandes ci-dessous sont celles du README officiel.

Sur macOS ou Linux, dans un terminal :

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

Sur Windows, dans PowerShell :

irm https://ollama.com/install.ps1 | iex

Si vous préférez ne pas exécuter un script téléchargé, le même README propose un installateur classique pour Mac et Windows, ainsi qu’une image Docker officielle. Prenez le réflexe de lire un script avant de le lancer : c’est une bonne hygiène de sécurité.

Étape 2 : télécharger et lancer un premier modèle

Une seule commande télécharge le modèle s’il est absent, puis ouvre une conversation dans le terminal :

ollama run gemma4

Sans précision, Ollama prend la variante par défaut, ici gemma4:e4b selon sa bibliothèque. Pour une machine plus modeste, choisissez une étiquette plus petite, par exemple ollama run qwen3.5:4b. Tapez votre question, puis /bye pour quitter.

Les autres commandes utiles, documentées dans l’aide en ligne de commande :

ollama pull qwen3.5:9b   # télécharger sans lancer
ollama ls                # lister les modèles installés
ollama ps                # voir les modèles chargés en mémoire
ollama stop gemma4       # décharger un modèle
ollama rm gemma4         # supprimer un modèle du disque

Résultat attendu : le modèle répond en quelques secondes, mot après mot. Débranchez le Wi-Fi et posez une autre question : la réponse arrive quand même. C’est la preuve que tout se passe sur votre machine.

Étape 3 : interroger le modèle depuis un programme

Ollama fonctionne aussi comme un serveur d’inférence : selon sa documentation, son API écoute sur http://localhost:11434, uniquement sur votre ordinateur. Testez-la avec curl, en reprenant l’exemple du README :

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4",
  "messages": [{"role": "user", "content": "Résume le principe du RGPD en trois phrases."}],
  "stream": false
}'

Plus pratique encore, Ollama propose un point d’accès compatible avec l’API d’OpenAI. D’après la page de compatibilité, une clé est demandée par la bibliothèque mais ignorée par Ollama :

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1/", api_key="ollama")
reponse = client.chat.completions.create(
    model="gemma4",
    messages=[{"role": "user", "content": "Propose trois titres pour un article sur le compost."}],
)
print(reponse.choices[0].message.content)

Ce détail change tout : la plupart des outils écrits pour une API en ligne acceptent une adresse personnalisée. Selon la même page, l’appel d’outils est pris en charge, ce qui permet de brancher un modèle local sur un framework d’agents. Atomic Agents, par exemple, cite Ollama parmi ses fournisseurs. Pour la suite, notre guide pour créer un agent IA, du no-code au code reprend la démarche complète, et le comparatif des frameworks d’agents vous aide à choisir l’outil.

Variante : llama.cpp, pour garder la main

llama.cpp est le moteur sur lequel s’appuie Ollama. L’utiliser directement donne plus de réglages : nombre de couches envoyées sur la carte graphique, taille du contexte, choix précis du fichier GGUF. Selon son README consulté le 22 octobre 2026, il prend en charge les puces Apple (Metal), les cartes NVIDIA (CUDA), AMD (HIP), Intel (SYCL), Vulkan et les processeurs, avec des quantifications de 1,5 à 8 bits.

Installation, d’après le README :

# macOS ou Linux
curl -LsSf https://llama.app/install.sh | sh

# Windows (PowerShell)
irm https://llama.app/install.ps1 | iex

Des binaires précompilés, une image Docker et une compilation depuis les sources sont aussi proposés. Ensuite, deux commandes :

# télécharger un modèle depuis Hugging Face et discuter
llama cli -hf ggml-org/Qwen3.5-0.8B-GGUF

# lancer un serveur compatible OpenAI, avec interface web
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF

L’exemple utilise un très petit modèle, idéal pour vérifier que tout fonctionne. D’après la documentation du serveur, l’option -hf choisit par défaut la quantification Q4_K_M, et le serveur écoute sur 127.0.0.1, port 9931 : ouvrez http://localhost:9931 dans votre navigateur pour discuter, ou pointez vos programmes vers http://localhost:9931/v1.

Critère	Ollama	llama.cpp
Prise en main	Très simple, une commande par modèle	Plus technique, beaucoup d’options
Catalogue	Bibliothèque ollama.com, étiquettes prêtes	Tout fichier GGUF, notamment sur Hugging Face
API	Native et compatible OpenAI, port 11434	Compatible OpenAI, port 9931 par défaut
Interface	Terminal et application	Terminal et interface web intégrée
Pour qui ?	Débuter vite, brancher une application	Optimiser une machine, tester des variantes

Vérifiez-vous Votre portable a 8 Go de mémoire au total et pas de carte graphique dédiée. Quel modèle essayez-vous en premier ?

Un petit modèle, comme qwen3.5:4b (3,3 à 4,0 Go sur la bibliothèque d’Ollama) ou le modèle de démonstration de llama.cpp. Un modèle de 7 Go remplirait presque toute la mémoire, système compris : il démarrerait mal ou très lentement.

Dépannage : les problèmes les plus courants

• C’est très lent. Le modèle ne tient sans doute pas en mémoire graphique et déborde sur le processeur. ollama ps montre où il est chargé. Passez à une étiquette plus petite ou à une quantification plus forte.
• « Out of memory » ou plantage au chargement. Même cause, ou une fenêtre de contexte trop grande : la mémoire de la conversation s’ajoute aux poids.
• Le disque se remplit. Supprimez les modèles inutiles avec ollama rm. Sur Windows, la variable OLLAMA_MODELS permet de les ranger sur un autre disque, selon la documentation.
• Des réponses médiocres en français. Essayez un modèle plus grand ou une autre famille : les petits modèles sont souvent plus à l’aise en anglais.

Aller plus loin : vos documents et la sécurité

Un modèle local devient vraiment utile quand il travaille sur vos propres fichiers. C’est le principe du RAG, qui donne vos documents à une IA : on retrouve les passages utiles, puis on les fournit au modèle. Ollama expose pour cela un point d’accès aux embeddings, d’après sa page de compatibilité.

Côté sécurité, gardez le serveur sur localhost. Si vous l’ouvrez au réseau, n’importe quel appareil connecté pourra s’en servir. Et un modèle local n’est pas immunisé contre l’injection de prompt : dès qu’il lit des contenus extérieurs et dispose d’outils, appliquez les mêmes règles que pour un agent en ligne, détaillées dans notre guide pour sécuriser un agent IA.