Ollama pour débutants : votre première étape pour exécuter un LLM en local

Le mois dernier, ma facture API OpenAI a dépassé 300 dollars. Ce n’était que des tests fréquents en phase de développement, et les coûts se sont accumulés plus vite que prévu. Pire encore : les documents traités contenaient des données internes à l’entreprise — les envoyer dans le cloud ne rassurait pas vraiment.

À ce moment-là, j’ai décidé de chercher une alternative locale. Après une semaine d’essais avec plusieurs outils, Ollama s’est imposé comme le plus simple à prendre en main.

Vous avez peut-être vécu la même situation : les services IA cloud coûtent de plus en plus cher, la confidentialité des données inquiète, ou vous devez tout simplement utiliser l’IA hors ligne. Ollama répond à ces problèmes. Il vous permet d’exécuter un grand modèle de langage sur votre propre machine, en quelques minutes, gratuitement, sans que vos données ne quittent l’ordinateur. Voici les pièges que j’ai rencontrés et ce que j’ai appris — pour vous faire gagner du temps.

Qu’est-ce qu’Ollama ?

Le nom prête parfois à confusion. Ollama n’est pas un modèle : c’est un outil pour exécuter des modèles. Comme Docker a simplifié la conteneurisation, Ollama rend l’exécution locale de grands modèles de langage accessible à tous.

En bref, vous téléchargez un modèle avec Ollama (par exemple Llama 3.2), puis vous dialoguez avec lui, lui demandez d’écrire du code, de traduire… Toute l’inférence se fait en local.

Pourquoi se compliquer la vie avec un modèle local ? ChatGPT et Claude ne sont-ils pas déjà très pratiques dans le cloud ?

Le cloud est pratique, c’est vrai. Mais à force d’utilisation, plusieurs problèmes apparaissent :

Le coût. Les appels API sont facturés au token. En phase de test avec des appels fréquents, la facture peut surprendre. J’ai vu des développeurs dépenser plusieurs centaines, voire milliers de dollars par mois.

La confidentialité. Toutes les conversations sont envoyées dans le cloud. Si vous traitez des documents internes, des données clients ou des informations sensibles, cela peut ne pas respecter les exigences de conformité.

Le réseau. Il faut être connecté pour utiliser le service. L’expérience est médiocre quand le réseau est instable, et impossible en mode totalement hors ligne.

Les limites. Les API cloud imposent des restrictions — débit, quotas, fonctionnalités… Parfois vous voulez tester une fonctionnalité et vous vous heurtez à ces contraintes.

Ollama répond directement à ces points. Une fois le modèle téléchargé sur votre machine, l’inférence se fait entièrement en local. Ça fonctionne sans réseau, vos données ne quittent pas la machine, pas de frais API, pas de limite d’appels.

Pour les développeurs, Ollama apporte un avantage supplémentaire : une API complète, compatible avec le format OpenAI. Vous testez en local pendant le développement — économique et pratique — puis basculez vers l’API cloud en production si besoin.

Installer Ollama : trois étapes

L’installation est vraiment simple. Chaque plateforme a ses particularités, mais en général quelques minutes suffisent.

Linux (le plus simple)

Sous Linux, une seule commande :

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

Une fois exécutée, Ollama est installé et le service démarre automatiquement.

Franchement, Linux est la plateforme que je recommande le plus. Déploiement serveur, conteneurisation — Linux gère tout très bien. Si vous prévoyez d’utiliser Ollama en production, Linux est le choix idéal.

L’installation manuelle est possible, mais je déconseille aux débutants de s’y aventurer. Si vraiment nécessaire, téléchargez le binaire et configurez le service systemd vous-même. Les détails figurent dans mon rapport de recherche ; je n’en parle pas ici.

macOS (interface graphique plus conviviale)

Deux méthodes sous macOS.

Avec Homebrew :

brew install ollama

Une fois installé, lancez ollama serve directement, ou brew services start ollama pour un service en arrière-plan.

Vous préférez éviter Homebrew ? Téléchargez le package .pkg sur le site officiel et double-cliquez. Les utilisateurs Mac connaissent bien ce type d’installation.

Petit conseil : sur Apple Silicon (M1/M2/M3), l’accélération GPU Metal s’active automatiquement, avec de bonnes performances. Mon MacBook Pro M2 fait tourner un modèle 8B sans problème ; le 13B aussi, avec une consommation mémoire plus élevée.

Windows (winget le plus pratique)

Sous Windows, utilisez winget :

Alibaba Cloud - Choix n°1 des développeurs, 15 % de réduction exclusive sur Lighthouse

Obtenir -15 % →Pub

winget install --id=Ollama.Ollama -e

Ou téléchargez le package .exe sur le site officiel. Après installation, Ollama démarre automatiquement ; une icône apparaît dans la zone de notification.

Vérifiez l’installation :

ollama --version

Si un numéro de version s’affiche, c’est bon. Simple, non ?

Exécuter votre premier modèle

Une fois installé, testons un modèle.

Choisissez d’abord un modèle. Pour débuter, je recommande llama3.2 ou qwen:8b. Le premier est le dernier modèle de Meta, avec de bonnes capacités générales ; le second est Qwen (Tongyi Qianwen), excellent pour le chinois.

Lancez :

ollama run llama3.2

Cette commande télécharge automatiquement le modèle (quelques minutes la première fois), puis ouvre une interface interactive.

Vous verrez :

>>> Send a message (/? for help)

Vous pouvez dialoguer. Essayez :

>>> 你好，介绍一下你自己

Le modèle répond en temps réel, comme dans un chat. Pour quitter, tapez /bye ou Ctrl+D.

Taille des modèles

Vous avez peut-être remarqué des chiffres comme 3b ou 8b dans les noms de modèles. Ils indiquent le nombre de paramètres — la « taille du cerveau » du modèle.

Modèle 3B : 3 milliards de paramètres, tourne sur un portable léger avec seulement 4 Go de RAM. Rapide, mais capacités relativement basiques. Adapté au dialogue simple et aux instructions d’outils.

Modèle 8B : 8 milliards de paramètres, le « sweet spot » pour la plupart des portables et PC de bureau. Nécessite 8 Go de RAM ; dialogue quotidien et aide à la programmation simple. C’est le niveau que j’utilise le plus.

Modèle 13B : 13 milliards de paramètres, 16 Go de RAM requis. Qualité de réponse nettement meilleure, contexte plus long ; adapté aux machines avec carte graphique milieu/haut de gamme.

Modèle 70B : 70 milliards de paramètres, 64 Go de RAM ou plus. Niveau serveur professionnel, capacités maximales mais exigences matérielles élevées. Honnêtement, les particuliers n’en ont généralement pas besoin.

Pour débuter, 3B à 8B suffisent. La plupart des portables récents les font tourner fluidement. Ne visez pas tout de suite les grands modèles : familiarisez-vous d’abord avec un petit modèle, puis montez en puissance si nécessaire.

Commandes courantes de gestion des modèles

Ollama propose un ensemble simple de commandes. Quelques-unes suffisent au quotidien.

Télécharger un modèle :

ollama pull llama3.2
ollama pull qwen:8b

La commande pull télécharge depuis la bibliothèque de modèles. Une fois en cache, les lancements suivants n’ont pas besoin de retélécharger.

Lister les modèles installés :

ollama list

Affiche tous les modèles téléchargés, avec nom, taille et date de modification.

Supprimer un modèle :

ollama rm llama3.2

Supprimez un modèle inutile pour libérer de l’espace.

Voir les détails d’un modèle :

ollama show llama3.2

Affiche les paramètres, le type de quantification et autres détails techniques.

D’autres commandes comme cp (copier) ou push (publier) sont peu utilisées ; consultez la documentation si besoin.

Quelques modèles recommandés

Selon l’usage :

Dialogue quotidien :

• llama3.2 : dernier Meta, bonnes capacités générales
• qwen:8b : Qwen, excellent en chinois
• mistral : modèle open source européen, bonnes performances

Aide à la programmation :

• codellama : optimisé pour la génération de code
• deepseek-coder : modèle code DeepSeek, très pratique

Multimodal (compréhension d’images) :

• llava : supporte la compréhension visuelle
• llama3.2-vision : version vision de Llama 3.2

En cas de doute, essayez d’abord llama3.2:3b ou qwen:8b. Les deux conviennent bien pour débuter et tournent légèrement.

Accélération GPU : l’écart de vitesse est réel

C’est un point crucial. Le CPU peut exécuter des modèles, mais l’écart est énorme — le GPU peut être 10 à 20 fois plus rapide.

La première fois, je n’avais pas configuré le GPU et le modèle était d’une lenteur insupportable. Une fois l’accélération activée, la vitesse a bondi.

Ollama prend en charge trois types de GPU : NVIDIA, AMD et Apple Silicon.

Cartes NVIDIA (série RTX)

La configuration NVIDIA est la plus simple — en grande partie automatique.

Il vous faut :

Railway - Plateforme de déploiement moderne, sans opérations complexes, en ligne en quelques minutes

Commencer →Pub

1. Les derniers pilotes NVIDIA (version 531 ou plus récente)
2. CUDA installé

Vérifiez que le GPU est disponible :

nvidia-smi

Si les informations de la carte s’affichent, c’est bon. Ollama utilise automatiquement le GPU à l’exécution.

Pour spécifier quels GPU utiliser :

export CUDA_VISIBLE_DEVICES=0,1

N’utilise que le premier et le second GPU. Utile sur les machines multi-cartes.

GPU dans Docker :

Si vous exécutez Ollama dans Docker, installez NVIDIA Container Toolkit :

docker run --gpus all ollama/ollama

Le conteneur pourra alors accéder au GPU de l’hôte.

Cartes AMD

AMD est un peu plus complexe : il faut installer ROCm.

Les GPU AMD compatibles ROCm incluent :

• Série Radeon Instinct (MI100, MI210, MI250, MI300X, etc.)
• Série Radeon RX (5700 XT, 5500 XT, 7600, 9070, etc.)
• Série Radeon PRO

Avec ROCm v7 ou plus récent, Ollama détecte et utilise automatiquement le GPU AMD.

Pour certaines architectures non officiellement supportées, essayez de surcharger la variable d’environnement :

export HSA_OVERRIDE_GFX_VERSION=10.3.0

AMD propose aussi un support expérimental Vulkan :

export OLLAMA_VULKAN=1

Apple Silicon (M1/M2/M3)

Les utilisateurs Mac ont la vie la plus simple. Apple Silicon active automatiquement l’accélération GPU Metal, sans configuration supplémentaire.

Un chip M avec 16 Go de RAM fait tourner un modèle 8B fluidement ; avec 32 Go, un 13B voire un 30B. La mémoire unifiée d’Apple Silicon est partagée entre GPU et CPU — la taille de la RAM détermine directement la taille du modèle exécutable.

Quelques astuces de performance

Outre l’accélération GPU :

Modèles quantifiés. Par défaut, quantification Q4_K_M — bon équilibre qualité/vitesse. Si la mémoire manque, essayez Q4_K_S : qualité légèrement inférieure, empreinte plus faible.

Flash Attention. Cette optimisation accélère nettement les scénarios à grand contexte :

export OLLAMA_FLASH_ATTENTION=1

Longueur du contexte. Par défaut 2048 ; si vous n’en avez pas besoin autant, réduisez :

export OLLAMA_CONTEXT_LENGTH=4096

Économise de la mémoire et accélère un peu.

Garder le modèle chargé. Par défaut, déchargement après 5 minutes d’inactivité. En usage fréquent, prolongez :

export OLLAMA_KEEP_ALIVE=30m

Ou -1 pour ne jamais décharger (tant que le service Ollama tourne). Chaque dialogue répond immédiatement, sans attendre le rechargement du modèle.

Intégration API : connecter Ollama à votre application

C’est là qu’Ollama apporte sa vraie valeur — une API complète pour l’intégrer dans vos applications.

Bases de l’API REST

Une fois Ollama démarré, il expose une API sur le port local 11434.

Deux points de terminaison courants :

Génération de texte :

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Why is the sky blue?"
}'

Complétion de chat :

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Hello!"}
  ]
}'

Par défaut, la réponse est en streaming. Pour une réponse complète, définissez "stream": false.

API compatible OpenAI — la fonctionnalité la plus précieuse

Très pratique. Ollama expose une interface compatible OpenAI : votre code OpenAI existant bascule vers un modèle local avec peu de modifications.

Point de terminaison compatible OpenAI :

http://localhost:11434/v1/chat/completions

Exemple Python :

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": "Say this is a test"}
    ]
)

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

Exemple JavaScript :

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'http://localhost:11434/v1',
  apiKey: 'ollama'
});

const response = await client.chat.completions.create({
  model: 'llama3.2',
  messages: [{ role: 'user', content: 'Hello!' }]
});

console.log(response.choices[0].message.content);

Ainsi, vous testez en local pendant le développement — économique — puis basculez vers l’API cloud en production pour la stabilité. Ou restez entièrement en local pour maîtriser coûts et confidentialité.

Ma méthode : une variable d’environnement bascule automatiquement entre local et cloud. En développement, local par défaut ; cloud uniquement quand les capacités cloud sont explicitement nécessaires.

Vultr - Serveur cloud NVMe haute performance, 32 emplacements mondiaux, déploiement Docker en un clic

Voir les tarifs →Pub

Bibliothèque Python d’Ollama

Outre la bibliothèque OpenAI, Ollama propose sa propre bibliothèque Python, plus directe :

pip install ollama

Usage de base :

import ollama

response = ollama.chat(model='llama3.2', messages=[
  {'role': 'user', 'content': 'Why is the sky blue?'},
])

print(response['message']['content'])

Mode streaming :

import ollama

stream = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Why is the sky blue?'}],
    stream=True,
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

Appel d’outils (Tool Calling)

Ollama prend en charge l’appel d’outils : le modèle peut invoquer des fonctions ou API externes. Utile pour construire des applications IA complexes.

Exemple :

import ollama

response = ollama.chat(
    model='llama3.1',
    messages=[{'role': 'user', 'content': 'What is the weather in Toronto?'}],
    tools=[{
        'type': 'function',
        'function': {
            'name': 'get_current_weather',
            'description': 'Get the current weather for a city',
            'parameters': {
                'type': 'object',
                'properties': {
                    'city': {'type': 'string', 'description': 'The name of the city'},
                },
                'required': ['city'],
            },
        },
    }],
)

print(response['message']['tool_calls'])

Le modèle décide s’il doit appeler un outil et renvoie les paramètres. Votre code exécute l’outil et renvoie le résultat au modèle.

Ollama ou LM Studio ?

Vous avez peut-être entendu parler de LM Studio, un autre outil pour exécuter des LLM en local. Comment choisir ?

Chacun a ses avantages, selon vos besoins.

Ollama :

• Principalement en ligne de commande, adapté aux développeurs
• Installation simple, une commande suffit
• Service API démarré automatiquement
• Parfait pour serveur et déploiement conteneurisé
• Idéal pour construire des applications et l’intégration automatisée

LM Studio :

• Interface graphique, intuitive
• Navigateur de modèles intégré, téléchargement facile
• Service API à démarrer manuellement
• Peu adapté au déploiement serveur
• Idéal pour explorer des modèles, apprendre et tester

En résumé :

• Construire une application IA, déployer sur serveur, automatiser par scripts → Ollama
• Découvrir rapidement des modèles, peu à l’aise en ligne de commande, exploration → LM Studio

Les deux peuvent se compléter. Je découvre et teste de nouveaux modèles dans LM Studio, puis les intègre officiellement dans Ollama. Les deux reposent sur llama.cpp ; les modèles sont entièrement compatibles.

Cas d’usage concrets

Quelques scénarios que j’ai réellement utilisés.

Assistant code local

Intégrez Ollama dans VS Code ou Cursor pour écrire, expliquer ou refactoriser du code. Je recommande codellama ou deepseek-coder.

Continue.dev et Aider se connectent directement à l’API Ollama. Une fois configuré, vous avez un assistant code gratuit en local.

Système de questions-réponses sur documents

Pour interroger un grand volume de documents, combinez Ollama et une base de données vectorielle pour une base de connaissances privée. Le flux :

1. Générer les vecteurs des documents via l’interface embeddings d’Ollama
2. Stocker dans une base vectorielle (Chroma, Qdrant, etc.)
3. À la question de l’utilisateur, rechercher les passages pertinents
4. Fournir ces passages comme contexte au modèle pour la réponse

C’est l’architecture RAG (Retrieval-Augmented Generation) typique. Entièrement local, les données ne quittent pas le réseau interne.

Base de connaissances privée

Documents internes, documentation technique, informations clients… Ces données sensibles ne devraient pas aller dans le cloud. Ollama permet un traitement entièrement local, conforme aux exigences de confidentialité.

Scénarios hors ligne

Déplacements, travail sur le terrain, réseau instable… L’IA cloud est indisponible, mais Ollama fonctionne entièrement hors ligne. Tant que l’ordinateur a de la batterie, l’assistant IA est là.

Environnement de développement et de test

Lors du développement d’applications IA, les appels API cloud fréquents coûtent cher. Ollama comme environnement de test fait économiser de l’argent. Une fois validé, basculez vers l’API cloud en production.

Questions fréquentes

J’ai rencontré quelques pièges ; voici les solutions.

Pour conclure

En résumé, l’objectif est de rendre les LLM locaux plus accessibles. Ollama y parvient — pas de configuration complexe, pas de formation IA approfondie, prise en main en quelques minutes. Gratuit, utilisable hors ligne, confidentialité des données assurée.

Prochaines étapes :

• Tester différents modèles pour trouver celui qui convient à vos besoins
• Intégrer Ollama dans votre flux de développement
• Explorer l’architecture RAG pour une base de connaissances privée
• Déployer sur un serveur pour un service IA partagé en équipe

L’ère de l’IA locale est arrivée. Avec Ollama, vous n’avez pas besoin du cloud pour exécuter des modèles de langage puissants sur votre propre machine. C’est parti pour votre aventure IA locale.

Auteur : Easton (blogueur technique, spécialisé en développement IA et déploiement local)

Références :

• Site officiel Ollama
• Ollama GitHub
• Documentation Ollama
• Bibliothèque de modèles Ollama