Faire tourner un modèle IA en local avec Ollama (gratuit et privé)

À la fin de ce tuto, tu auras un modèle IA qui tourne sur ta propre machine, interrogeable de trois façons : dans le terminal, via une API REST depuis tes scripts Python, et dans une interface de chat type ChatGPT — le tout sans rien envoyer dans le cloud, sans abonnement. Tu sauras aussi choisir la bonne taille de modèle et dépanner les problèmes courants.

Durée : 25 min (hors téléchargement des modèles, selon ta connexion).

Ce dont tu as besoin

RAM : 8 Go minimum pour un modèle 7B, 16 Go pour être à l'aise, 32 Go pour les gros modèles.
Disque : 4–5 Go par modèle téléchargé.
GPU : pas obligatoire. Un GPU NVIDIA récent ou une puce Apple Silicon (M1+) accélère énormément ; sinon ça tourne sur CPU, plus lentement.
OS : macOS, Windows (10+) ou Linux.

Étape 1 — Installer Ollama

Va sur ollama.com et télécharge l'installeur. C'est un binaire autonome, sans dépendance.

macOS / Linux en terminal :

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

Windows : télécharge et lance le .exe. Vérifie ensuite :

ollama --version
# ollama version 0.x.x

Étape 2 — Lancer ton premier modèle

Une seule commande télécharge le modèle (s'il manque) puis ouvre une conversation :

ollama run mistral

Première fois : tu vois le téléchargement (~4 Go pour Mistral 7B), puis :

>>> Explique-moi ce qu'est un token en IA, en une phrase.
Un token est l'unité de base — un morceau de mot — que les modèles de
langage utilisent pour découper et traiter le texte.

Tu parles à un LLM qui tourne entièrement chez toi. Quitte avec /bye.

Modèles recommandés selon ta RAM :

Modèle RAM Pour quoi qwen2.5:1.5b 4 Go Tâches simples, tri, très rapide llama3.2 8 Go Généraliste, bon en français mistral 8 Go Bon équilibre qualité/vitesse qwen2.5:14b 16 Go Qualité proche du cloud qwen2.5:32b 32 Go Le plus capable, exigeant

Gérer tes modèles :

ollama list          # ce que tu as installé
ollama rm mistral    # supprimer un modèle
ollama pull llama3.2 # télécharger sans lancer

Étape 3 — Comprendre taille et quantification (le couple qualité/vitesse)

Deux nombres décident de tout :

La taille (en milliards de paramètres : 1.5B, 7B, 14B…). Plus c'est gros, plus c'est capable, mais plus il faut de mémoire et plus c'est lent.
La quantification (le suffixe q4, q8…). C'est une compression du modèle. q4 divise la mémoire par ~4 avec une perte de qualité minime : c'est le défaut d'Ollama, et le bon choix dans 90 % des cas.

ollama run qwen2.5:14b-instruct-q4_K_M   # version quantifiée explicite

Règle simple : commence petit, monte en taille seulement si la qualité ne suffit pas. Un 7B rapide qui répond bien vaut mieux qu'un 14B qui rame.

Étape 4 — L'API locale (le vrai intérêt)

Ollama expose automatiquement une API REST sur http://localhost:11434, compatible avec le format d'OpenAI. Teste-la :

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral",
    "messages": [{"role": "user", "content": "Résume le RAG en une phrase."}]
  }'

Réponse JSON standard :

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": "Le RAG enrichit les réponses d'une IA avec tes propres documents, sans réentraîner le modèle."
    }
  }]
}

Le point clé : le format est identique à l'API OpenAI. Si tu as déjà du code qui appelle OpenAI, tu changes juste l'URL de base.

Étape 5 — L'appeler depuis Python

La librairie officielle openai accepte une base_url custom — donc elle pilote Ollama sans modification :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # ignoré en local, mais requis par la lib
)

resp = client.chat.completions.create(
    model="mistral",
    messages=[{"role": "user", "content": "Donne 3 idées de noms pour une app de veille IA."}],
)
print(resp.choices[0].message.content)

C'est exactement le code d'un appel OpenAI — seule l'URL change. Tout ce que tu apprends sur l'API OpenAI (function calling, streaming…) se transpose en local.

Étape 6 — Une interface type ChatGPT en local (Open WebUI)

Pour une vraie interface de chat plutôt que le terminal, Open WebUI se branche sur Ollama en une commande Docker :

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Ouvre http://localhost:3000 : tu retrouves une interface façon ChatGPT, multi-conversations, qui utilise tes modèles Ollama — 100 % local.

Dépannage des problèmes courants

« connection refused » sur localhost:11434 → le service n'est pas lancé. Sur Linux : ollama serve dans un terminal. Sur Mac/Windows, vérifie que l'app Ollama tourne (icône dans la barre).
Réponses très lentes → tu es sur CPU, ou le modèle dépasse ta RAM (le système « swappe »). Prends un modèle plus petit ou plus quantifié.
« out of memory » → modèle trop gros pour ta RAM/VRAM. Descends d'une taille ou passe en q4.
Mauvaise qualité en français → essaie llama3.2 ou un modèle Mistral, meilleurs en français que certains modèles anglophones.
Le GPU n'est pas utilisé → sur NVIDIA, vérifie que les drivers CUDA sont à jour ; Ollama bascule automatiquement sur GPU s'il le détecte (ollama ps montre l'usage).

Ce que le local ne remplace pas

Un Mistral 7B local ne rivalise pas avec les meilleurs modèles cloud sur les tâches très complexes. Le local excelle sur trois axes : confidentialité (rien ne sort de ta machine), coût zéro à l'usage, disponibilité hors ligne. Pour du raisonnement poussé ou du contexte très long, le cloud garde l'avantage. Beaucoup d'usages réels mélangent les deux : local pour le sensible et le volume, cloud pour les cas durs.

À retenir

Ollama installe et lance un LLM en local en une commande, sur les trois OS. Choisis la taille selon ta RAM et reste en quantification q4 par défaut. Son API locale compatible OpenAI te laisse brancher tes scripts Python, n8n ou une interface comme Open WebUI sans changer de code. Démarre petit, monte en gamme seulement si nécessaire, et réserve le local aux cas où confidentialité et coût priment sur la puissance brute.