Ollama : Fais tourner un LLM sur ton PC sans Internet ni abonnement

Tu veux utiliser ChatGPT mais tu flippes d'envoyer tes données dans le cloud ? Tu rêves de bidouiller un vrai LLM sans API key ni connexion Internet ? Bonne nouvelle : avec Ollama, tu fais tourner des modèles comme Llama 4, Mistral ou DeepSeek directement sur ta machine. Zéro serveur, zéro facture, zéro espionnage. Et tout ça en 10 lignes de commande.

Le problème que résout Ollama

Faire tourner un LLM (Large Language Model) en local, c'était un cauchemar il y a encore un an. Il fallait compiler des dépendances C++, télécharger des dizaines de gigaoctets de poids, jongler avec PyTorch et CUDA, écrire 200 lignes de boilerplate... Bref, une usine à gaz réservée aux barbus.

Ollama a tout changé. C'est le Docker des LLMs : un binaire unique, une CLI minimaliste, et un simple ollama run pour démarrer un modèle. Derrière, il gère automatiquement le téléchargement, la quantification, l'inférence GPU, et expose une API REST prête à l'emploi.

À la fin de ce tutoriel, tu sauras : - Installer Ollama sur Linux, Mac ou Windows - Télécharger et lancer un LLM en une commande - Dialoguer avec lui via le terminal - Créer un assistant personnalisé avec un prompt système - L'utiliser dans un script Python avec zéro dépendance cloud

Étape 1 : Installer Ollama

Sur Linux

bash

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

Si tu préfères comprendre ce que fait le script avant de l'exécuter (bon réflexe) :

bash

curl -fsSL https://ollama.com/install.sh -o ollama-install.sh
cat ollama-install.sh   # lis-le
sudo sh ollama-install.sh

L'installeur détecte automatiquement ta distrib (Ubuntu, Fedora, Arch...) et ajoute le service systemd.

Sur Mac

bash

brew install ollama

Ou télécharge l'app depuis ollama.com.

Sur Windows

Télécharge l'installateur MSI depuis ollama.com/download. L'installation ajoute Ollama au PATH ; tu pourras tout faire depuis PowerShell.

Ce que tu dois voir : après l'installation, la commande ollama --version doit retourner ollama version 0.11.x (ou plus récent).

Premier test

bash

ollama --version

Si ça affiche une version, tout roule. Lance le serveur en arrière-plan :

bash

ollama serve

Ollama tourne désormais sur http://localhost:11434. Tu peux le laisser en arrière-plan : il ne consomme quasiment rien quand aucun modèle n'est chargé.

Étape 2 : Ton premier LLM en local

On va commencer par un modèle petit mais costaud : Llama 3.2 3B, environ 2 Go. Il est assez léger pour tourner même sur un PC portable sans carte graphique dédiée.

bash

ollama run llama3.2:3b

La première fois, Ollama télécharge le modèle automatiquement. Ensuite, tu tombes directement dans un prompt interactif :

plaintext

>>> Bonjour, qui es-tu ?
Bonjour ! Je suis Llama, un modèle de langage créé par Meta. Je peux répondre
à tes questions, t'aider avec du code, rédiger des textes...

Tu peux poser toutes tes questions. Pour sortir, tape /bye.

Changer de modèle

Ollama propose une bibliothèque de modèles impressionnante. Voici quelques incontournables :

bash

ollama run mistral         # Mistral 7B, excellent en français (~4 Go)
ollama run deepseek-r1:8b  # DeepSeek R1 8B, raisonnement (~5 Go)
ollama run llama3.2:1b     # Ultra-léger, tourne sur un Raspberry Pi (~600 Mo)
ollama run gemma3:12b      # Gemma 3 de Google, 12B (~7 Go)
ollama run qwen3:8b        # Qwen 3, excellent en code (~5 Go)

La syntaxe est ollama run <modele>:<taille>. Si tu omets la taille, Ollama choisit la version par défaut (souvent la plus grosse).

Gérer tes modèles locaux

bash

ollama list           # Voir les modèles installés
ollama pull llama3.2  # Télécharger sans lancer
ollama rm llama3.2:3b # Supprimer un modèle

Étape 3 : Créer un assistant personnalisé

Tu peux créer un « Modelfile » — l'équivalent du Dockerfile pour personnaliser ton LLM. C'est ultra simple.

Imagine que tu veux un assistant qui répond TOUJOURS en français, avec un ton de professeur bienveillant, et qui refuse de répondre aux questions hors-sujet. Crée ce fichier :

bash

# Fichier : Modelfile
FROM llama3.2:3b

SYSTEM """Tu es ProfesseurIA, un assistant pédagogique qui parle UNIQUEMENT en français.
Tu réponds à toutes les questions de manière claire, patiente et encourageante.
Si on te pose une question hors-sujet (météo, sport, politique), réponds poliment :
« Désolé, je suis un professeur, pas un encyclopédiste ! »
N'utilise jamais d'anglais, même si l'utilisateur te parle en anglais."""

PARAMETER temperature 0.7
PARAMETER top_p 0.9

Puis construis ton assistant :

bash

ollama create professeur-ia -f Modelfile

Et lance-le :

bash

ollama run professeur-ia

Testons :

plaintext

>>> What is the capital of France?
Désolé, je suis un professeur, pas un encyclopédiste !

>>> Explique-moi ce qu'est une dérivée en mathématiques
Avec plaisir ! Imagine que tu roules à vélo. La dérivée, c'est ta vitesse
instantanée à un moment précis : à quel point ta position change vite.
Mathématiquement, on écrit f'(x) = lim(h→0) [f(x+h) - f(x)] / h...

Félicitations, tu viens de créer ton premier agent IA sur mesure, sans écrire une ligne de code !

Étape 4 : Utiliser Ollama depuis Python

Le terminal, c'est cool. Mais le vrai pouvoir d'Ollama, c'est son API REST. Tu peux l'appeler depuis n'importe quel langage.

Voici un script Python complet qui interroge ton modèle, avec gestion du streaming :

python

# Fichier : assistant.py
import requests
import json

OLLAMA_URL = "http://localhost:11434/api/generate"

def demander(prompt: str, modele: str = "professeur-ia") -> str:
    """Envoie un prompt au modèle et récupère la réponse complète."""
    payload = {
        "model": modele,
        "prompt": prompt,
        "stream": False,   # Mettre True pour du streaming temps réel
        "options": {
            "temperature": 0.7,
            "num_predict": 500  # Limite le nombre de tokens générés
        }
    }

    reponse = requests.post(OLLAMA_URL, json=payload)
    data = reponse.json()
    return data["response"]

# Test rapide
if __name__ == "__main__":
    print("🤖 Assistant IA local prêt !\n")
    while True:
        question = input("❓ Toi : ")
        if question.lower() in ("quit", "exit", "bye"):
            print("👋 À bientôt !")
            break
        resultat = demander(question)
        print(f"🤖 ProfesseurIA : {resultat}\n")

Pour l'exécuter, installe juste requests :

bash

pip install requests
python3 assistant.py

Ce que tu dois voir : ton assistant répond en français à chaque question. Tout tourne en local, ta connexion Internet peut être coupée, ça marche quand même.

Étape 5 : Streaming temps réel (comme ChatGPT)

Pour une expérience fluide, active le streaming. Le modèle envoie chaque token dès qu'il est généré :

python

# Fichier : assistant_stream.py
import requests
import json

OLLAMA_URL = "http://localhost:11434/api/generate"

def demander_stream(prompt: str, modele: str = "professeur-ia"):
    """Streaming : affiche la réponse token par token."""
    payload = {
        "model": modele,
        "prompt": prompt,
        "stream": True,
        "options": {"temperature": 0.7}
    }

    print("🤖 ProfesseurIA : ", end="", flush=True)

    with requests.post(OLLAMA_URL, json=payload, stream=True) as r:
        for ligne in r.iter_lines():
            if not ligne:
                continue
            data = json.loads(ligne)
            token = data.get("response", "")
            print(token, end="", flush=True)

            if data.get("done", False):
                break

    print()  # Saut de ligne final

# Conversation interactive
if __name__ == "__main__":
    print("🤖 Assistant IA local avec streaming activé !\n")
    while True:
        question = input("❓ Toi : ")
        if question.lower() in ("quit", "exit", "bye"):
            print("👋 À bientôt !")
            break
        demander_stream(question)
        print()

Lance-le : python3 assistant_stream.py. Les mots apparaissent progressivement, exactement comme ChatGPT.

Étape 6 : RAG — Interroge tes propres documents

Le Retrieval-Augmented Generation (RAG), c'est la technique qui permet à ton LLM de « lire » tes documents et de répondre à partir d'eux. Voici un mini-RAG en 30 lignes :

python

# Fichier : mini_rag.py
import requests, json

OLLAMA_CHAT = "http://localhost:11434/api/chat"

# 1. Tes documents (base de connaissances)
DOCUMENTS = {
    "reglement": "Le télétravail est autorisé le mercredi et le vendredi. "
                 "Les réunions d'équipe ont lieu le lundi à 10h en présentiel. "
                 "Le parking est gratuit pour les employés.",
    "menus": "Lundi : poulet rôti. Mardi : salade César. Mercredi : sushi. "
             "Jeudi : boeuf bourguignon. Vendredi : pizza."
}

def repondre_avec_contexte(question: str, modele: str = "llama3.2:3b") -> str:
    """Cherche dans les documents + répond avec contexte."""

    # 2. Cherche le document le plus pertinent (naïf : par mot-clé)
    contexte = ""
    for cle, contenu in DOCUMENTS.items():
        if any(mot.lower() in contenu.lower() for mot in question.split()):
            contexte = contenu
            break

    if not contexte:
        contexte = "Aucun document pertinent trouvé."

    # 3. Construis un prompt avec contexte
    prompt = f"""Contexte documentaire :
{contexte}

Question de l'utilisateur : {question}

Réponds UNIQUEMENT en te basant sur le contexte ci-dessus.
Si le contexte ne contient pas l'information, dis-le honnêtement."""

    # 4. Appel à Ollama
    payload = {
        "model": modele,
        "messages": [{"role": "user", "content": prompt}],
        "stream": False
    }

    r = requests.post(OLLAMA_CHAT, json=payload)
    return r.json()["message"]["content"]


if __name__ == "__main__":
    print("📚 Mini-RAG prêt ! Pose des questions sur le règlement ou les menus.\n")
    while True:
        q = input("❓ Question : ")
        if q.lower() in ("quit", "exit"):
            break
        print(f"🤖 Réponse : {repondre_avec_contexte(q)}\n")

Ce que tu dois voir : « Quand est-ce que je peux être en télétravail ? » → « Le mercredi et le vendredi. » « Qu'est-ce qu'on mange jeudi ? » → « Boeuf bourguignon. » « Quelle est la capitale du Brésil ? » → « Je ne trouve pas cette information dans le contexte fourni. »

Pièges classiques (et comment les éviter)

Piège n°1 : Modèle trop gros pour ta RAM

Un modèle 7B nécessite ~4-5 Go de RAM, un 13B ~8-10 Go. Si ta RAM est pleine, le système utilise le swap et tout devient horriblement lent. Solution : choisis la plus petite variante (llama3.2:1b ou qwen3:1.8b) et surveille htop.

Piège n°2 : Oublier de lancer `ollama serve`

Si tu reçois connection refused, c'est que le serveur n'est pas démarré. Lance ollama serve dans un terminal séparé, ou configure le service systemd :

bash

sudo systemctl enable ollama
sudo systemctl start ollama
sudo systemctl status ollama  # vérifie qu'il tourne

Piège n°3 : Les guillemets dans les Modelfile

Le bloc SYSTEM """ """ utilise des triples guillemets. Si ton prompt contient un """, ça casse tout. Solution : échappe-les ou utilise des délimiteurs différents comme '''.

Piège n°4 : Le GPU n'est pas utilisé

Ollama détecte automatiquement CUDA (NVIDIA) et Metal (Mac). Vérifie que ton GPU est reconnu :

bash

ollama run llama3.2:3b --verbose

Si tu vois ggml_cuda_init: found 1 CUDA devices, ton GPU bosse. Sinon, vérifie tes drivers.

Piège n°5 : Timeout sur l'API avec des gros modèles

La première inférence après chargement peut prendre 10-30 secondes. Sur l'API, le timeout par défaut de requests peut couper. Mets un timeout plus long :

python

requests.post(OLLAMA_URL, json=payload, timeout=120)

Pour aller plus loin

1. Interface web avec Open WebUI

Si le terminal te gave, installe Open WebUI — un clone de l'interface ChatGPT qui se connecte à ton serveur Ollama :

bash

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

Puis va sur http://localhost:3000 : tu as ChatGPT, mais chez toi.

2. Fine-tuner un modèle avec tes données

Avec le Modelfile, tu ne modifies pas les poids. Pour un vrai fine-tuning, explore Unsloth (gratuit, open-source) qui te permet d'affiner Llama ou Mistral sur ton propre dataset, même sur une seule RTX 3090.

3. Utiliser Ollama avec LangChain

Tu peux brancher Ollama directement dans LangChain (qu'on a couvert dans le tutoriel précédent) :

python

from langchain_ollama import OllamaLLM
llm = OllamaLLM(model="llama3.2:3b")
print(llm.invoke("Explique-moi les trous noirs"))

💡 Idée d'illustration : Un terminal split-screen : à gauche, la commande ollama run llama3.2:3b avec une conversation visible ; à droite, le script Python avec des lignes de code colorées et la mention « LOCAL — No Cloud ». En arrière-plan, une icône de cadenas et un logo Ollama stylisé. Le tout avec le titre « Ton IA. Ton PC. Tes règles. »

Le problème que résout Ollama

Étape 1 : Installer Ollama

Sur Linux

Sur Mac

Sur Windows

Premier test

Étape 2 : Ton premier LLM en local

Changer de modèle

Gérer tes modèles locaux

Étape 3 : Créer un assistant personnalisé

Étape 4 : Utiliser Ollama depuis Python

Étape 5 : Streaming temps réel (comme ChatGPT)

Étape 6 : RAG — Interroge tes propres documents

Pièges classiques (et comment les éviter)

Piège n°1 : Modèle trop gros pour ta RAM

Piège n°2 : Oublier de lancer ollama serve

Piège n°3 : Les guillemets dans les Modelfile

Piège n°4 : Le GPU n'est pas utilisé

Piège n°5 : Timeout sur l'API avec des gros modèles

Pour aller plus loin

1. Interface web avec Open WebUI

2. Fine-tuner un modèle avec tes données

3. Utiliser Ollama avec LangChain

Piège n°2 : Oublier de lancer `ollama serve`