Ollama : installer et utiliser un modèle IA en local sur son PC

En bref

Ollama est un outil qui permet de faire tourner des modèles d’IA en local sur un ordinateur.

Il s’utilise en ligne de commande, mais il expose aussi une API locale sur http://localhost:11434. Cette API permet de connecter Ollama à des scripts, des interfaces web, des outils de développement ou des applications compatibles avec une partie du format OpenAI.

Ollama est intéressant pour tester des LLM open weight sans envoyer toutes ses requêtes vers un service cloud. Il ne transforme pas un petit PC en serveur d’IA magique : le choix du modèle, la RAM, la VRAM et le système d’exploitation restent importants.

À quoi sert Ollama

Ollama simplifie trois opérations qui sont souvent pénibles quand on découvre l’IA locale :

1. télécharger un modèle ;
2. le lancer depuis le terminal ;
3. l’exposer via une API locale.

Sans Ollama, il faut souvent manipuler directement des fichiers de modèles, choisir un moteur d’inférence, configurer des chemins, gérer des paramètres et comprendre les formats de quantification.

Avec Ollama, le premier test peut tenir en quelques commandes :

ollama pull llama3.2
ollama run llama3.2

Le modèle est téléchargé, stocké localement, puis lancé dans une session interactive.

Installation

La documentation officielle d’Ollama propose des installations pour Windows, Linux et macOS.

Windows

Sous Windows, Ollama fonctionne comme une application native. Après installation, la commande ollama devient disponible dans PowerShell, cmd ou un terminal compatible.

La documentation Windows indique aussi que l’API locale est servie sur :

http://localhost:11434

Ollama pour Windows demande Windows 10 22H2 ou plus récent. Pour l’accélération GPU, il faut aussi des pilotes compatibles.

Linux

Sous Linux, l’installation officielle se fait avec :

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

Le service peut ensuite être démarré et vérifié avec systemctl selon l’installation :

sudo systemctl start ollama
sudo systemctl status ollama

macOS

Sur macOS, Ollama peut être installé depuis le site officiel. Les machines Apple Silicon utilisent l’accélération Metal.

Choisir un modèle

Le choix du modèle est plus important que l’installation.

Un modèle trop gros peut être lent, instable ou inutilisable sur une machine modeste. Pour commencer, il vaut mieux choisir un modèle compact et populaire plutôt que viser directement un très gros modèle.

La bibliothèque officielle Ollama permet de rechercher des modèles et de voir les tags disponibles. Les noms suivent généralement ce format :

nom-du-modele:tag

Exemples :

ollama pull llama3.2
ollama pull qwen3
ollama pull gemma3

Le tag latest est utilisé par défaut quand aucun tag n’est indiqué. Pour un usage durable, il est préférable de noter le nom complet du modèle utilisé dans ses tests.

Commandes utiles

Lancer un modèle

ollama run llama3.2

Cette commande ouvre une conversation dans le terminal.

Lister les modèles installés

ollama list

Cette commande permet de vérifier quels modèles sont déjà présents sur la machine.

Télécharger un modèle sans le lancer

ollama pull llama3.2

C’est utile pour préparer une machine avant un test ou une démonstration.

Vérifier la version

ollama -v

La version doit être notée quand un article, un tutoriel ou un test dépend d’un comportement précis.

Utiliser l’API locale

Ollama expose une API locale. Par défaut, elle écoute sur :

http://localhost:11434

Un appel simple à l’API native peut ressembler à ceci :

Invoke-RestMethod `
  -Uri "http://localhost:11434/api/generate" `
  -Method Post `
  -ContentType "application/json" `
  -Body '{"model":"llama3.2","prompt":"Explique Ollama en une phrase.","stream":false}'

L’endpoint /api/generate sert à générer une réponse à partir d’un prompt.

L’endpoint /api/chat sert plutôt aux conversations structurées avec des messages.

La documentation officielle indique aussi d’autres endpoints utiles :

1. /api/pull pour télécharger un modèle ;
2. /api/tags pour lister les modèles locaux ;
3. /api/show pour afficher les informations d’un modèle ;
4. /api/embed pour générer des embeddings ;
5. /api/ps pour lister les modèles chargés en mémoire ;
6. /api/version pour récupérer la version du serveur.

Compatibilité avec l’API OpenAI

Ollama fournit une compatibilité avec une partie de l’API OpenAI. Le but est de connecter plus facilement des outils existants à un serveur local.

Exemple Python avec le client OpenAI :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1/",
    api_key="ollama",
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "Explique Ollama en une phrase."}
    ],
)

print(response.choices[0].message.content)

Le champ api_key reste obligatoire côté client OpenAI, mais il est ignoré par Ollama dans cet usage local.

Il faut rester précis : cette compatibilité ne veut pas dire que toute l’API OpenAI est reproduite à l’identique. Il faut vérifier les endpoints et champs supportés dans la documentation Ollama avant de brancher une application sérieuse.

Exemple d’usage concret

Un usage simple consiste à utiliser Ollama comme moteur local pour tester des prompts.

Workflow :

1. installer Ollama ;
2. télécharger un modèle ;
3. tester le modèle dans le terminal ;
4. appeler l’API locale depuis un script ;
5. brancher ensuite une interface comme Open WebUI, LibreChat ou un outil compatible.

Cette progression évite de commencer par une pile trop lourde.

Avantages

Ollama a plusieurs avantages pour un usage personnel ou technique :

1. installation simple ;
2. modèles stockés localement ;
3. ligne de commande facile à tester ;
4. API locale pratique ;
5. compatibilité partielle avec le format OpenAI ;
6. intégration possible avec des interfaces et des outils de développement ;
7. bon point d’entrée pour comprendre l’IA locale.

Limites

Ollama ne supprime pas les contraintes matérielles.

Un modèle de grande taille demande beaucoup de RAM ou de VRAM. Si la carte graphique n’est pas compatible ou pas assez puissante, l’exécution peut basculer sur le CPU et devenir lente.

Les limites principales :

1. performances très variables selon le matériel ;
2. modèles volumineux à télécharger ;
3. qualité dépendante du modèle choisi ;
4. consommation mémoire parfois élevée ;
5. compatibilité OpenAI partielle, à vérifier selon l’application ;
6. usage serveur public à éviter sans couche de sécurité supplémentaire.

Pour un usage exposé sur un réseau, il faut traiter Ollama comme un service sensible. Laisser une API de génération accessible sans contrôle est une mauvaise idée.

Matériel et GPU

La documentation officielle indique une prise en charge des GPU NVIDIA, AMD Radeon via ROCm selon les systèmes, Apple Metal et Vulkan expérimental.

Pour un premier test, un CPU suffit parfois avec un petit modèle. Pour un usage confortable, une carte graphique compatible et assez de VRAM changent fortement l’expérience.

Sur Windows, il faut vérifier les pilotes NVIDIA ou AMD. Sur Linux, les pilotes GPU et les droits d’accès aux périphériques peuvent devenir le vrai sujet technique.

Vérification minimale après installation

Après installation, trois vérifications suffisent pour savoir si la base fonctionne :

ollama -v
ollama pull llama3.2
ollama run llama3.2

Puis vérifier l’API :

Invoke-RestMethod -Uri "http://localhost:11434/api/version"

Si l’API répond avec une version, le serveur local Ollama est actif.

Quand utiliser Ollama

Ollama est pertinent pour :

1. tester des modèles open weight ;
2. apprendre l’IA locale ;
3. prototyper une application LLM ;
4. travailler hors cloud sur des données non critiques ;
5. comparer plusieurs modèles ;
6. brancher une interface locale ;
7. alimenter un petit pipeline RAG expérimental.

Il est moins adapté si l’objectif est d’obtenir immédiatement une haute disponibilité, une gestion fine des utilisateurs, une supervision avancée ou une exposition publique sécurisée. Dans ce cas, il faut ajouter d’autres briques autour.

Pour aller plus loin

Ces ressources permettent de prolonger le sujet avec des outils et documentations concrètes :

• Open WebUI : interface web auto-hébergée souvent utilisée avec Ollama.
• LM Studio : autre outil local utile pour comparer l’expérience avec Ollama.
• llama.cpp : moteur d’inférence à connaître pour comprendre la base technique de nombreux usages locaux.
• Compatibilité OpenAI d’Ollama : documentation officielle pour connecter un client ou un script existant.
• ollama-python : bibliothèque Python officielle pour piloter Ollama depuis un script.
• Documentation Qdrant : base vectorielle utile pour construire un pipeline RAG local autour d’Ollama.

Lexique

LLM : grand modèle de langage capable de générer ou analyser du texte.

Open weight : modèle dont les poids sont disponibles, mais pas forcément avec une licence totalement open source.

VRAM : mémoire de la carte graphique. Elle influence fortement la taille des modèles utilisables confortablement.

API locale : interface accessible sur la machine, ici via localhost, pour appeler Ollama depuis un script ou une application.

Embedding : représentation numérique d’un texte, utile pour la recherche sémantique et les pipelines RAG.

RAG : méthode qui combine recherche documentaire et génération de réponse par un modèle.

Sources & Ressources

• Source de veille : vidéo YouTube Open-Source AI Tools That Feel ILLEGAL To Use.
• Documentation Ollama Windows : https://docs.ollama.com/windows
• Documentation Ollama Linux : https://docs.ollama.com/linux
• Référence CLI Ollama : https://docs.ollama.com/cli
• Référence API Ollama : https://github.com/ollama/ollama/blob/main/docs/api.md
• Compatibilité OpenAI : https://docs.ollama.com/api/openai-compatibility
• Support matériel GPU : https://docs.ollama.com/gpu
• Bibliothèque de modèles Ollama : https://ollama.com/library