# Faire tourner une IA sur son ordinateur avec Ollama

> Installer Ollama sur Mac, Windows ou Linux, lancer un premier modèle avec ollama run, savoir où il se range et le brancher à vos applis, étape par étape.

- Niveau : Débutant
- Thème : IA locale
- Durée : 15 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/ollama/

Ollama est un logiciel gratuit, sous licence MIT, qui télécharge des modèles d'IA ouverts (Gemma, Qwen, gpt-oss, DeepSeek…) et les fait tourner sur votre ordinateur. Une fois le modèle téléchargé, vos questions et vos documents restent sur la machine : aucun compte n'est demandé pour les modèles locaux, et Ollama dit ne voir ni vos requêtes ni vos données. On le pilote dans un terminal avec la commande `ollama`, et d'autres applications s'y branchent pour profiter du même modèle.

## Comment ça marche

Ollama tient en deux pièces : un serveur qui tourne en arrière-plan, et la commande `ollama` qui lui parle. Quand vous demandez un modèle, le serveur le télécharge depuis le catalogue d'ollama.com et le range dans un dossier de votre ordinateur. Quand vous lui posez une question, il charge ce modèle en mémoire, celle du processeur graphique de préférence, puis écrit la réponse mot après mot. Le terminal et les applications passent tous par ce serveur, à l'adresse `localhost:11434`.

![Ollama tient en trois morceaux : le catalogue en ligne, un petit serveur sur votre ordinateur avec le dossier des modèles, et ce qui s'y branche.](https://quelleia.com/guides/ollama/schema-fonctionnement.svg)

*Ollama tient en trois morceaux : le catalogue en ligne, un petit serveur sur votre ordinateur avec le dossier des modèles, et ce qui s'y branche.*

## À quoi ça sert

Faire tourner un modèle chez soi rend service dans plusieurs situations :

- **Garder ses documents pour soi.** Résumer un contrat, relire un compte rendu ou trier des notes de santé sans les envoyer à un service en ligne.
- **Travailler hors connexion.** Dans un train ou un avion, le modèle répond tant que l'ordinateur est allumé.
- **Brancher l'IA sur ses propres outils.** Un script qui classe des courriels, un agent de code qui lit votre projet, une interface de discussion pour toute la famille sur le réseau de la maison : tous parlent au même serveur Ollama.
- **Essayer sans payer.** Les modèles locaux sont gratuits et sans limite d'usage, la seule dépense étant l'électricité.

Un modèle local reste en général moins fort que les meilleurs modèles en ligne : le classement des modèles qui tournent en local, sur QUELLE IA, montre l'écart du moment.

## Ce qu'il faut avant de commencer

La mémoire compte plus que le processeur. Pour un premier essai avec Gemma 4 E2B, un petit modèle de Google, Ollama conseille 8 Go de mémoire vidéo libre, ou 8 Go de mémoire unifiée sur un Mac. Avec moins, le modèle déborde sur la mémoire ordinaire de l'ordinateur et répond plus lentement.

- **Mac** : macOS 14 Sonoma ou plus récent. Les puces Apple M utilisent leur processeur graphique ; un Mac à processeur Intel fait tourner les modèles sur le seul processeur, donc lentement.
- **Windows** : Windows 10 22H2 ou plus récent, édition Famille ou Professionnel. Avec une carte NVIDIA, il faut un pilote 551.61 ou plus récent ; les cartes AMD Radeon passent par ROCm ou par Vulkan. L'installation demande 4 Go d'espace libre, sans droits d'administrateur.
- **Linux** : un script d'installation en une ligne, qui installe aussi Ollama comme service.

Prévoyez ensuite de la place pour les modèles : de quelques Go à plusieurs dizaines de Go chacun.

## Installer Ollama

Tout part de la page de téléchargement d'Ollama, ollama.com/download, qui détecte votre système.

![Page web d'Ollama intitulée Download Ollama, avec trois onglets macOS, Linux et Windows, l'onglet Linux ouvert sur la commande curl -fsSL https://ollama.com/install.sh | sh.](https://quelleia.com/guides/ollama/page-telechargement.webp)

*La page de téléchargement officielle d'Ollama, capturée le 17 novembre 2026 : un onglet par système et la ligne d'installation à copier.*

### Sur Mac

**Installer Ollama sur Mac**

- Mac, site de l'éditeur : https://ollama.com/download/mac (Fichier Ollama.dmg ou commande d'installation ; macOS 14 Sonoma ou plus récent), relevé le 17 octobre 2026
- Mac, dépôt officiel : https://github.com/ollama/ollama/releases/latest (Ollama.dmg et archive Ollama-darwin.zip dans les versions GitHub), relevé le 17 octobre 2026

1. Téléchargez le fichier `Ollama.dmg` sur la page officielle et ouvrez-le.
2. Glissez l'application Ollama dans le dossier Applications, puis lancez-la.
3. Au premier démarrage, Ollama vérifie que la commande `ollama` est accessible dans le terminal et propose de créer le lien qui manque dans `/usr/local/bin` : acceptez.

La page de téléchargement propose aussi une installation en une ligne, à coller dans le Terminal :

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

### Sur Windows

**Installer Ollama sur Windows**

- Windows, site de l'éditeur : https://ollama.com/download/windows (Installateur OllamaSetup.exe ou commande PowerShell ; Windows 10 22H2 ou plus récent), relevé le 17 octobre 2026
- Windows, dépôt officiel : https://github.com/ollama/ollama/releases/latest (OllamaSetup.exe et archives x64 et ARM64 dans les versions GitHub), relevé le 17 octobre 2026

1. Téléchargez `OllamaSetup.exe` sur la page officielle et lancez-le. Il s'installe dans votre dossier personnel.
2. Ollama démarre et reste en arrière-plan. La commande `ollama` fonctionne ensuite dans l'invite de commandes comme dans PowerShell.

L'équivalent en ligne de commande, dans PowerShell :

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

> Bon à savoir : sur certains vieux terminaux de Windows 10, la barre de progression s'affiche en petits carrés. Changer la police du terminal règle le problème, d'après la documentation d'Ollama.

### Sur Linux

**Installer Ollama sur Linux**

- Linux, site de l'éditeur : https://ollama.com/download/linux (Script d'installation en une ligne ; installation manuelle décrite dans la documentation), relevé le 17 octobre 2026
- Linux, gestionnaire de paquets : https://hub.docker.com/r/ollama/ollama (Image Docker officielle ollama/ollama), relevé le 17 octobre 2026
- Linux, dépôt officiel : https://github.com/ollama/ollama/releases/latest (Archives x64 (dont variante ROCm) et ARM64 (dont Jetson) dans les versions GitHub), relevé le 17 octobre 2026

1. Ouvrez un terminal et collez la ligne d'installation. Le script installe Ollama et le déclare comme service système, qui démarre avec la machine.

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

2. Vérifiez que le service tourne, et lisez son journal en cas de souci :

```bash
sudo systemctl status ollama
journalctl -e -u ollama
```

Pour mettre Ollama à jour sous Linux, relancez la même ligne d'installation. Sur Mac et Windows, l'application télécharge seule ses mises à jour : un clic sur son icône, dans la barre des menus ou la barre des tâches, puis « Restart to update » les installe.

## Lancer un premier modèle

Ouvrez un terminal et tapez :

```bash
ollama run gemma4:e2b
```

Au premier lancement, Ollama télécharge le modèle, ce qui prend quelques minutes selon votre connexion. Une invite `>>>` apparaît ensuite : écrivez votre question et validez. Pour un texte sur plusieurs lignes, encadrez-le de trois guillemets `"""`. Tapez `/bye` pour quitter.

Le nom après `run` se lit en deux parties. `gemma4` désigne la famille du modèle, et ce qui suit les deux-points (`e2b`, `26b`…) choisit la taille. Sans étiquette, Ollama prend la version par défaut de la famille, notée `latest`. Chaque page du catalogue, sur ollama.com/library, liste les tailles proposées avec leur poids : pour Gemma 4, l'étiquette `e2b` pèse de 4,6 à 7,5 Go selon la version, la version par défaut de 6,6 à 9,5 Go.

![Page web ollama.com de gemma4 : étiquettes vision, tools, thinking, audio, cloud, puis un tableau des versions gemma4:latest, cloud, e2b, e4b, 12b, 26b et 31b avec leur taille de 4,6 à 20 Go et un contexte de 128K ou 256K.](https://quelleia.com/guides/ollama/catalogue-gemma4.webp)

*La page de Gemma 4 dans le catalogue d'Ollama, capturée le 17 novembre 2026 : chaque étiquette avec sa taille, sa fenêtre de contexte et ce qu'elle accepte en entrée.*

On peut aussi poser une question sans entrer dans la conversation, ce qui sert dans un script :

```bash
ollama run gemma4:e2b "Résume en trois lignes ce qu'est la mémoire vidéo."
```

## Quel modèle pour une machine de 16 Go

Avec 16 Go de mémoire, voici les modèles les mieux classés par QUELLE IA qui tiennent dans votre machine. La liste suit l'édition de la semaine.

**Les meilleurs modèles pour une machine de 16 Go**

1. [Qwen3.5-9B](https://quelleia.com/modeles/qwen3-5-9b/) : score 66,1 (allégée à 8 bits, 11,7 Go)
2. [Gemma 4 12B IT](https://quelleia.com/modeles/gemma-4-12b-it/) : score 64,8 (provisoire) (allégée à 4 bits, 8,3 Go)
3. [Ministral 3 14B](https://quelleia.com/modeles/ministral-3-14b/) : score 64,8 (provisoire) (allégée à 4 bits, 9,7 Go)
4. [Qwen3-14B](https://quelleia.com/modeles/qwen3-14b/) : score 62,9 (allégée à 4 bits, 10,2 Go)
5. [Qwen3.5-4B](https://quelleia.com/modeles/qwen3-5-4b/) : score 62,9 (provisoire) (complète, 10,7 Go)

Mémoire utile retenue : 14 Go, celle des machines suivies de 16 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.
[Quel modèle sur ma machine](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

La règle derrière ce tableau, les autres paliers de mémoire et la différence entre une carte graphique et un Mac sont détaillés dans le guide « Quel modèle pour ma machine ». Retenez pour l'instant qu'un modèle trop gros pour votre mémoire se lance quand même, mais devient très lent.

## Voir, vérifier et ranger ses modèles

Quatre commandes suffisent au quotidien :

```bash
ollama list            # les modèles téléchargés, avec leur taille
ollama show gemma4:e2b # la fiche d'un modèle : taille, contexte, version, capacités
ollama ps              # les modèles chargés en mémoire en ce moment
ollama rm gemma4:e2b   # supprimer un modèle pour récupérer la place
```

Voici ce que donnent les deux premières sur le mini-PC Linux de QUELLE IA.

![Terminal sombre : la commande ollama --version répond « ollama version is 0.21.1 », puis ollama list affiche neuf modèles avec leur identifiant, leur taille de 274 Mo à 19 Go et leur date de téléchargement.](https://quelleia.com/guides/ollama/terminal-liste.webp)

*ollama --version et ollama list sur le mini-PC Linux de QUELLE IA, le 17 novembre 2026. Ollama y tourne dans un conteneur Docker, en version 0.21.1, plus ancienne que la dernière publiée (0.40.16, le 9 novembre 2026).*

La commande `ollama show` dit d'un coup d'œil ce que vous avez téléchargé. La ligne `quantization` indique la version allégée du modèle (ici `Q4_K_M`, autour de 4 bits par poids), et la rubrique des capacités dit s'il lit les images (`vision`), s'il sait appeler des outils (`tools`) ou s'il réfléchit avant de répondre (`thinking`).

![Terminal sombre : la commande ollama show gemma4:26b affiche l'architecture gemma4, 25.8B paramètres, une longueur de contexte de 262144, la quantification Q4_K_M, puis les capacités completion, vision, tools et thinking.](https://quelleia.com/guides/ollama/terminal-show.webp)

*ollama show gemma4:26b sur le même mini-PC : 25,8 milliards de paramètres, une fenêtre de contexte de 262 144 jetons, une version allégée Q4_K_M, et ce que le modèle sait faire.*

La commande `ollama ps` montre où le modèle s'est installé, dans sa colonne `PROCESSOR`. « 100% GPU » signifie qu'il tient entièrement dans la mémoire du processeur graphique, la situation idéale. « 100% CPU » indique qu'il tourne sur le processeur seul. Un partage comme « 48%/52% CPU/GPU » signale un modèle trop gros, réparti entre les deux et nettement ralenti. La colonne `UNTIL` dit quand il sera déchargé : Ollama garde un modèle en mémoire 5 minutes après la dernière question, et `ollama stop gemma4:e2b` le libère tout de suite.

## Où sont rangés les modèles

| Système | Dossier par défaut |
| --- | --- |
| Mac | `~/.ollama/models` |
| Windows | `C:\Users\%username%\.ollama\models` |
| Linux (installation standard) | `/usr/share/ollama/.ollama/models` |

Pour les mettre ailleurs, sur un second disque par exemple, définissez la variable d'environnement `OLLAMA_MODELS` avec le nouveau dossier, puis redémarrez Ollama. Sous Linux, ce dossier doit appartenir à l'utilisateur `ollama` (`sudo chown -R ollama:ollama <dossier>`). La manière de poser une variable change selon le système :

- **Mac** : `launchctl setenv OLLAMA_MODELS "/Volumes/Disque/ollama"`, puis relancez l'application.
- **Windows** : quittez Ollama, cherchez « variables d'environnement » dans les paramètres, ajoutez la variable pour votre compte, puis relancez Ollama depuis le menu Démarrer.
- **Linux** : `sudo systemctl edit ollama`, ajoutez la ligne `Environment="OLLAMA_MODELS=/chemin"` sous `[Service]`, puis `sudo systemctl daemon-reload` et `sudo systemctl restart ollama`.

## Brancher une appli sur Ollama

Ollama ouvre un petit serveur sur votre machine, à l'adresse `http://localhost:11434`. Les applications s'y adressent comme elles parleraient à un service en ligne, avec une API compatible avec celles d'OpenAI et d'Anthropic.

**Sur Mac, Claude ou ChatGPT.** Dans l'application Ollama, la section Apps branche Claude Desktop ou ChatGPT Desktop (en mode Codex) sur vos modèles locaux. Le choix des modèles se fait ensuite dans Réglages, puis Apps.

**Un agent de code.** Depuis le dossier de votre projet, une commande lance l'agent déjà branché sur Ollama :

```bash
ollama launch claude     # Claude Code
ollama launch codex      # Codex CLI, à installer avant
ollama launch opencode   # OpenCode
```

Ollama propose d'installer Claude Code ou OpenCode s'ils manquent, puis vous demande quel modèle utiliser. Pour un agent, la documentation d'Ollama conseille une fenêtre de contexte d'au moins 64 000 jetons (voir plus bas).

**Une interface de discussion.** Le dépôt d'Ollama recense des interfaces faites par d'autres, comme Open WebUI, qu'on fait pointer sur `http://localhost:11434`.

**Votre propre programme.** Tout client prévu pour l'API d'OpenAI fonctionne en changeant l'adresse. La clé est obligatoire pour la bibliothèque, mais Ollama l'ignore :

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1/", api_key="ollama")
reponse = client.chat.completions.create(
    model="gemma4:e2b",
    messages=[{"role": "user", "content": "Bonjour"}],
)
print(reponse.choices[0].message.content)
```

> Bon à savoir : Ollama n'écoute par défaut que votre propre machine (adresse 127.0.0.1). La variable `OLLAMA_HOST` permet de l'ouvrir au réseau local. Ne l'ouvrez jamais sur internet : n'importe qui pourrait se servir de votre processeur graphique.

## Deux réglages à connaître

**La fenêtre de contexte** désigne la quantité de texte que le modèle garde sous les yeux pendant l'échange. Ollama la règle d'après la mémoire vidéo : 4 000 jetons sous 24 Gio, 32 000 de 24 à 48 Gio, 256 000 au-delà. Une fenêtre plus grande prend plus de mémoire. Sur une machine juste, un contexte trop large fait déborder le modèle sur le processeur, et `ollama ps` le montre aussitôt. On la change dans les réglages de l'application (un curseur), ou avec la variable `OLLAMA_CONTEXT_LENGTH` (par exemple `64000` pour un agent de code). La colonne `CONTEXT` de `ollama ps` affiche la valeur retenue.

Pour régler le contexte d'un agent de code, étape par étape :

1. Sur Mac ou Windows, ouvrez les réglages de l'application Ollama et poussez le curseur de longueur de contexte vers 64 000 jetons. Passez à l'étape 4.
2. Sous Linux, tapez `sudo systemctl edit ollama` et ajoutez sous `[Service]` la ligne `Environment="OLLAMA_CONTEXT_LENGTH=64000"`.
3. Rechargez la configuration et redémarrez le service : `sudo systemctl daemon-reload`, puis `sudo systemctl restart ollama`.
4. Lancez le modèle, puis `ollama ps` dans un second terminal : la colonne `CONTEXT` doit afficher la nouvelle valeur, et `PROCESSOR` rester à « 100% GPU ». Si une part passe sur le processeur, revenez à une valeur plus basse ou prenez un modèle plus petit.

**Le mode local seulement.** Ollama propose aussi des modèles « cloud », qui tournent sur ses serveurs avec un compte. Pour être sûr que rien ne sorte de la machine, la variable `OLLAMA_NO_CLOUD=1` coupe ces modèles et la recherche web.

Pour choisir la suite, les pages machines de QUELLE IA (liens ci-dessous) donnent, machine par machine, les modèles qui tiennent et leur vitesse mesurée ou estimée.

## Pour aller plus loin

- [Quel modèle sur ma machine](https://quelleia.com/local/)
- [Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)
- [Ollama](https://quelleia.com/logitheque/ollama/)
- [Trouver mon modèle](https://quelleia.com/trouver/)
- [Les logiciels d'IA locale](https://quelleia.com/logitheque/usages/local-ordinateur/)
- [Quel modèle d'IA pour ma machine, de 8 à 128 Go](https://quelleia.com/guides/quel-modele-pour-ma-machine.md) (guide, amateur)
- [LM Studio, l'IA locale sans ouvrir de terminal](https://quelleia.com/guides/lm-studio.md) (guide, débutant)
- [Quantification : Q4, Q8, ce qu'on gagne et ce qu'on perd](https://quelleia.com/guides/quantification.md) (guide, expert)
- [Sur mini lab AI](https://minilabai.com/guides/ollama-modeles-locaux/) : un guide du même auteur, qui va plus loin

## Sources

- https://docs.ollama.com/quickstart (lue le 17 novembre 2026)
- https://docs.ollama.com/macos (lue le 17 novembre 2026)
- https://docs.ollama.com/windows (lue le 17 novembre 2026)
- https://docs.ollama.com/linux (lue le 17 novembre 2026)
- https://docs.ollama.com/cli (lue le 17 novembre 2026)
- https://docs.ollama.com/faq (lue le 17 novembre 2026)
- https://docs.ollama.com/context-length (lue le 17 novembre 2026)
- https://docs.ollama.com/api/openai-compatibility (lue le 17 novembre 2026)
- https://ollama.com/download/mac (lue le 17 novembre 2026)
- https://ollama.com/download/windows (lue le 17 novembre 2026)
- https://ollama.com/library/gemma4/tags (lue le 17 novembre 2026)
- https://github.com/ollama/ollama (lue le 17 novembre 2026)
- https://github.com/ollama/ollama/releases/latest (lue le 17 novembre 2026)
