Fiche de référence de la CLI Ollama : ls, serve, run, ps et autres commandes (mise à jour 2026)

Cette fiche de référence de la CLI Ollama se concentre sur les commandes utilisées quotidiennement (ollama ls, ollama serve, ollama run, ollama ps, gestion des modèles et flux de travail courants), avec des exemples prêts à copier-coller.

Elle comprend également une section brève sur les “paramètres de performance” pour vous aider à découvrir (et approfondir) OLLAMA_NUM_PARALLEL et les paramètres connexes.

Cette fiche de référence Ollama se concentre sur les commandes CLI, la gestion des modèles et la personnalisation, Mais nous avons également inclus des appels curl.

Pour une vue d’ensemble de la place d’Ollama parmi les options locales, auto-hébergées et cloud — y compris vLLM, Docker Model Runner, LocalAI et les fournisseurs cloud — consultez Hébergement LLM : Comparaison des infrastructures locales, auto-hébergées et cloud. Si vous comparez différentes solutions d’hébergement local de LLM, consultez notre comparaison complète d’Ollama, vLLM, LocalAI, Jan, LM Studio et plus encore. Pour ceux qui recherchent des alternatives aux interfaces en ligne de commande, Docker Model Runner offre une approche différente du déploiement de LLM.

Installation d’Ollama (téléchargement et installation CLI)

• Option 1 : Télécharger depuis le site web
  • Visitez ollama.com et téléchargez l’installateur pour votre système d’exploitation (Mac, Linux ou Windows).
• Option 2 : Installation via la ligne de commande
  • Pour les utilisateurs Mac et Linux, utilisez la commande :

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

• Suivez les instructions à l’écran et entrez votre mot de passe si demandé.

Exigences système Ollama (RAM, stockage, CPU)

• Système d’exploitation : Mac, Linux ou Windows
• Mémoire (RAM) : 8 Go minimum, 16 Go ou plus recommandés
• Stockage : Au moins ~10 Go d’espace libre (les fichiers de modèle peuvent être très volumineux, voir ici Déplacer les modèles Ollama vers un autre lecteur )
• Processeur : Un CPU relativement moderne (datant des 5 dernières années). Si vous êtes curieux de savoir comment Ollama utilise différentes architectures CPU, consultez notre analyse de la façon dont Ollama utilise les cœurs de performance et efficaces des CPU Intel.

Pour des charges de travail IA sérieuses, vous pourriez vouloir comparer les options matérielles. Nous avons benchmarké NVIDIA DGX Spark vs Mac Studio vs RTX-4080 avec Ollama, et si vous envisagez d’investir dans du matériel haut de gamme, notre comparaison des prix et capacités du DGX Spark fournit une analyse détaillée des coûts.

Commandes CLI Ollama de base

Liens rapides : Commande Ollama serve · Commande Ollama launch · Commande Ollama run · Drapeaux Ollama run · Commande Ollama ps · Commande Ollama show · Ollama signin · Bases CLI Ollama · Paramètres de performance (OLLAMA_NUM_PARALLEL) · Plongée dans les requêtes parallèles

CLI Ollama (définition)

Ollama CLI est l’interface en ligne de commande pour gérer les modèles et les exécuter/les servir localement. La plupart des flux de travail se résument à :

• Démarrer le serveur : ollama serve
• Exécuter un modèle : ollama run <model>
• Voir ce qui est chargé/en cours : ollama ps
• Gérer les modèles : ollama pull, ollama list, ollama rm

Gestion des modèles Ollama : commandes pull et list

Lister les modèles :

ollama list

identique à :

ollama ls

Cette commande liste tous les modèles qui ont été téléchargés sur votre système, avec leurs tailles de fichiers sur votre hdd/ssd, comme ceci :

$ ollama ls
NAME                                                    ID              SIZE      MODIFIED     
deepseek-r1:8b                                          6995872bfe4c    5.2 GB    il y a 2 semaines     
gemma3:12b-it-qat                                       5d4fa005e7bb    8.9 GB    il y a 2 semaines     
LoTUs5494/mistral-small-3.1:24b-instruct-2503-iq4_NL    4e994e0f85a0    13 GB     il y a 3 semaines     
dengcao/Qwen3-Embedding-8B:Q4_K_M                       d3ca2355027f    4.7 GB    il y a 4 semaines     
dengcao/Qwen3-Embedding-4B:Q5_K_M                       7e8c9ad6885b    2.9 GB    il y a 4 semaines     
qwen3:8b                                                500a1f067a9f    5.2 GB    il y a 5 semaines     
qwen3:14b                                               bdbd181c33f2    9.3 GB    il y a 5 semaines     
qwen3:30b-a3b                                           0b28110b7a33    18 GB     il y a 5 semaines     
devstral:24b                                            c4b2fa0c33d7    14 GB     il y a 5 semaines  

Télécharger un modèle : ollama pull

ollama pull mistral-nemo:12b-instruct-2407-q6_K

Cette commande télécharge le modèle spécifié (par exemple, Gemma 2B, ou mistral-nemo:12b-instruct-2407-q6_K) sur votre système. Les fichiers de modèle peuvent être très volumineux, alors surveillez l’espace utilisé par les modèles sur le disque dur ou ssd. Vous pourriez même vouloir déplacer tous les modèles Ollama de votre répertoire personnel vers un autre lecteur plus grand et meilleur

Téléverser un modèle : ollama push

ollama push my-custom-model

Téléverse un modèle local vers le registre Ollama pour que d’autres puissent le récupérer. Vous devez être connecté en premier (ollama signin) et le nom du modèle doit être préfixé par votre nom d’utilisateur Ollama, par exemple myuser/my-model. Utilisez --insecure si vous téléversez vers un registre privé via HTTP :

ollama push myuser/my-model --insecure

Copier un modèle : ollama cp

ollama cp llama3.2 my-llama3-variant

Crée une copie locale d’un modèle sous un nouveau nom sans rien re-télécharger. C’est pratique avant de modifier un Modelfile — copiez d’abord, personnalisez la copie, et gardez l’original intact :

ollama cp qwen3:14b qwen3-14b-custom
ollama create qwen3-14b-custom -f ./Modelfile

Commande Ollama show

ollama show affiche des informations sur un modèle téléchargé.

ollama show qwen3:14b

Par défaut, il affiche la carte du modèle (architecture, longueur de contexte, longueur d’embedding, quantification, etc.). Il existe trois drapeaux utiles :

# Voir exactement quel prompt système et modèle ont été utilisés pour construire le modèle
ollama show deepseek-r1:8b --modelfile

# Vérifier la taille de la fenêtre de contexte et autres paramètres d'inférence
ollama show qwen3:14b --parameters

# Détail complet au niveau des tenseurs (utile pour déboguer la quantification)
ollama show llama3.2 --verbose

La sortie --modelfile est particulièrement utile avant de personnaliser un modèle : vous pouvez copier le Modelfile de base et l’éditer à partir de là plutôt que d’en écrire un à partir de zéro.

Commande Ollama serve

ollama serve démarre le serveur Ollama local (port HTTP par défaut 11434).

ollama serve

Commande “ollama serve” (exemple compatible systemd) :

# définir les variables d'environnement, puis démarrer le serveur
# rendre ollama disponible sur l'adresse IP de l'hôte
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_NUM_PARALLEL=2
ollama serve

Commande Ollama run

Exécuter un modèle :

ollama run gpt-oss:20b

Cette commande démarre le modèle spécifié et ouvre un REPL interactif pour l’interaction. Vous voulez comprendre comment Ollama gère plusieurs requêtes concurrentes ? En savoir plus sur la façon dont Ollama gère les requêtes parallèles dans notre analyse détaillée.

ollama run exécute un modèle dans une session interactive, donc dans le cas de gpt-oss:120b, vous verrez quelque chose comme ceci :

$ ollama run gpt-oss:120b
>>> Envoyez un message (/? pour l'aide)

vous pouvez taper vos questions ou commandes et le modèle répondra.

>>> qui êtes-vous ?
Réflexion...
L'utilisateur demande "qui êtes-vous ?" Question simple. Devrait répondre en tant que ChatGPT, un modèle de langage IA, entraîné par OpenAI, 
etc. Fournir une brève intro. Probablement demander s'ils ont besoin d'aide.
...réflexion terminée.

Je suis ChatGPT, un modèle de langage IA créé par OpenAI. J'ai été entraîné sur une large gamme de textes pour pouvoir vous aider à 
répondre à des questions, brainstormer des idées, expliquer des concepts, rédiger des écrits, résoudre des problèmes et bien plus encore. Considérez-moi 
comme un assistant virtuel polyvalent — ici pour fournir des informations, un support et une conversation quand vous en avez besoin. Comment puis-je vous aider aujourd'hui ?

>>> Envoyez un message (/? pour l'aide)

Pour quitter la session interactive ollama, appuyez sur Ctrl+D, ou vous pouvez taper /bye, même résultat :

>>> /bye
$ 

Exemples de commande Ollama run

Pour exécuter un modèle et poser une seule question en mode non interactif :

printf "Donnez-moi 10 one-liners bash pour l'analyse de logs.\n" | ollama run llama3.2

Si vous voulez voir la réponse LLM détaillée et verbeuse dans la session ollama, exécutez le modèle avec le paramètre --verbose ou -v :

$ ollama run gpt-oss:20b --verbose
>>> qui êtes-vous ?
Réflexion...
Nous devons répondre à une question simple : "qui êtes-vous ?" L'utilisateur demande "qui êtes-vous ?" Nous pouvons répondre que nous 
sommes ChatGPT, un grand modèle de langage entraîné par OpenAI. Nous pouvons également mentionner les capacités. L'utilisateur s'attend probablement 
à une brève introduction. Nous resterons sympathiques.
...réflexion terminée.

Je suis ChatGPT, un grand modèle de langage créé par OpenAI. Je suis là pour aider à répondre aux questions, offrir des explications, 
brainstormer des idées et discuter d'une large gamme de sujets — de la science et l'histoire à l'écriture créative 
et aux conseils quotidiens. Dites-moi simplement de quoi vous voulez parler !

durée totale :       1.118585707s
durée de chargement :        106.690543ms
nombre d'évaluations de prompt :    71 token(s)
durée d'évaluation du prompt : 30.507392ms
taux d'évaluation du prompt :     2327.30 tokens/s
nombre d'évaluations :           132 token(s)
durée d'évaluation :        945.801569ms
taux d'évaluation :            139.56 tokens/s
>>> /bye
$ 

Oui, c’est exact, c’est 139 tokens par seconde. Le gpt-oss:20b est très rapide. Si vous, comme moi, avez un GPU avec 16 Go de VRAM, consultez les détails de comparaison de vitesse des LLM dans Meilleurs LLM pour Ollama sur GPU 16GB VRAM.

Astuce : Si vous voulez que le modèle soit disponible via HTTP pour plusieurs applications, démarrez le serveur avec ollama serve et utilisez le client API plutôt que des sessions interactives longues.

Drapeaux de la commande Ollama run (référence complète)

Remplacer les paramètres du modèle sans Modelfile (-p / –parameters)

Le drapeau -p vous permet de changer les paramètres d’inférence à l’exécution sans créer un Modelfile. Vous pouvez empiler plusieurs drapeaux -p :

# Augmenter la fenêtre de contexte et baisser la température
ollama run qwen3:14b -p num_ctx=32768 -p temperature=0.5

# Exécuter une tâche de codage avec une sortie déterministe
ollama run devstral:24b -p temperature=0 -p num_ctx=65536

Paramètres courants que vous pouvez définir ainsi :

Saisie multi-lignes dans le REPL

Entourez le texte de triples guillemets (""") pour entrer un prompt multi-lignes sans soumettre prématurément :

>>> """Résumez ceci en une phrase :
... Le renard brun rapide saute par-dessus le chien paresseux.
... Cela s'est produit un mardi.
... """

Modèles multimodaux (images)

Pour les modèles capables de vision (par exemple gemma3, llava), passez un chemin d’image directement dans le prompt :

ollama run gemma3 "Qu'y a-t-il dans cette image ? /home/user/screenshot.png"

Génération d’embeddings via CLI

Les modèles d’embedding sortent un tableau JSON au lieu de texte. Redirigez le texte directement pour des embeddings rapides :

echo "Bonjour le monde" | ollama run nomic-embed-text

Pour des charges de travail d’embedding en production, utilisez le point de terminaison REST /api/embeddings ou le client Python à la place.

Forcer la sortie JSON (–format)

ollama run llama3.2 --format json "Listez 5 capitales au format JSON"

Le modèle est instruit de retourner du JSON valide. Utile lors de la redirection de la sortie vers jq ou un script qui s’attend à des données structurées.

Commande Ollama stop

Cette commande arrête le modèle spécifié en cours d’exécution.

ollama stop llama3.1:8b-instruct-q8_0

Ollama expulse les modèles automatiquement après un certain temps. Vous pouvez spécifier ce temps, par défaut 4 minutes. Si vous ne voulez pas attendre le temps restant, vous pouvez utiliser cette commande ollama stop. Vous pouvez également forcer le modèle hors de la VRAM en appelant le point de terminaison API /generate avec le paramètre keep_alive=0, voir ci-dessous pour la description et l’exemple.

Commande Ollama ps

ollama ps affiche les modèles et sessions actuellement en cours d’exécution (utile pour déboguer “pourquoi ma VRAM est-elle pleine ?”).

ollama ps

Voici un exemple de sortie de ollama ps :

NAME           ID              SIZE     PROCESSOR    CONTEXT    UNTIL
gpt-oss:20b    17052f91a42e    14 GB    100% GPU     4096       dans 4 minutes

Vous voyez ici sur mon PC que gpt-oss:20b rentre parfaitement dans les 16 Go de VRAM de mon GPU, et occupe seulement 14 Go.

Si j’exécute ollama run gpt-oss:120b puis appelle ollama ps, le résultat ne sera pas aussi brillant : 78% des couches sont sur le CPU, et cela avec une fenêtre de contexte de 4096 tokens. Ce sera encore plus si j’ai besoin d’augmenter le contexte.

NAME            ID              SIZE     PROCESSOR          CONTEXT    UNTIL
gpt-oss:120b    a951a23b46a1    66 GB    78%/22% CPU/GPU    4096       dans 4 minutes

Commande Ollama launch (intégrations de codage IA)

ollama launch est une commande introduite dans Ollama v0.15 (janvier 2026) qui vous offre une configuration sans configuration, en une ligne, pour les assistants de codage IA populaires exécutés contre votre serveur Ollama local.

Pourquoi utiliser ollama launch ?

Avant ollama launch, connecter un agent de codage comme Claude Code ou Codex à un backend Ollama local signifiait configurer manuellement les variables d’environnement, pointer l’outil vers le bon point de terminaison API et choisir un modèle compatible. ollama launch gère tout cela pour vous de manière interactive.

Si vous exécutez déjà Ollama localement et voulez un assistant de codage agent sans payer d’appels API ou envoyer du code dans le cloud, ollama launch est le chemin le plus rapide.

Intégrations prises en charge

Utilisation de base

# Sélecteur interactif — choisissez une intégration depuis un menu
ollama launch

# Lancer une intégration spécifique directement
ollama launch claude

# Lancer avec un modèle spécifique
ollama launch claude --model qwen3-coder

# Configurer l'intégration sans la lancer (utile pour inspecter les paramètres)
ollama launch droid --config

Modèles recommandés

Les agents de codage ont besoin d’une fenêtre de contexte longue pour contenir le contexte de fichiers entiers et l’historique de conversation multi-tours. Ollama recommande des modèles avec au moins 64 000 tokens de contexte :

Si votre GPU ne peut pas contenir le modèle, Ollama offre également des variantes hébergées dans le cloud (par exemple qwen3-coder:480b-cloud) qui s’intègrent de la même manière mais routent l’inférence vers la couche cloud d’Ollama — nécessitant ollama signin.

Exemple : exécution de Claude Code localement avec Ollama

# 1. Assurez-vous que le modèle est disponible
ollama pull qwen3-coder

# 2. Lancer Claude Code contre celui-ci
ollama launch claude --model qwen3-coder

Ollama définit les variables d’environnement nécessaires et démarre Claude Code en pointant vers http://localhost:11434 automatiquement. Vous pouvez ensuite utiliser Claude Code exactement comme vous le feriez normalement — la seule différence est que l’inférence se produit sur votre propre matériel.

Paramètres de performance (OLLAMA_NUM_PARALLEL)

Si vous voyez des files d’attente ou des dépassements de temps sous charge, le premier paramètre à apprendre est OLLAMA_NUM_PARALLEL.

• OLLAMA_NUM_PARALLEL = combien de requêtes Ollama exécute en parallèle.
• Une valeur plus élevée peut augmenter le débit, mais peut augmenter la pression sur la VRAM et les pics de latence.

Exemple rapide :

OLLAMA_NUM_PARALLEL=2 ollama serve

Pour une explication complète (y compris les stratégies de réglage et les modes de défaillance), consultez :

• Comment Ollama gère les requêtes parallèles

Libération du modèle Ollama de la VRAM (keep_alive)

Lorsqu’un modèle est chargé dans la VRAM (mémoire GPU), il y reste même après que vous ayez fini de l’utiliser. Pour libérer explicitement un modèle de la VRAM et libérer la mémoire GPU, vous pouvez envoyer une requête à l’API Ollama avec keep_alive: 0.

• Libérer le modèle de la VRAM en utilisant curl :

curl http://localhost:11434/api/generate -d '{"model": "MODELNAME", "keep_alive": 0}'

Remplacez MODELNAME par votre nom de modèle réel, par exemple :

curl http://localhost:11434/api/generate -d '{"model": "qwen3:14b", "keep_alive": 0}'

• Libérer le modèle de la VRAM en utilisant Python :

import requests

response = requests.post(
    'http://localhost:11434/api/generate',
    json={'model': 'qwen3:14b', 'keep_alive': 0}
)

C’est particulièrement utile lorsque :

• Vous avez besoin de libérer de la mémoire GPU pour d’autres applications
• Vous exécutez plusieurs modèles et voulez gérer l’utilisation de la VRAM
• Vous avez fini d’utiliser un grand modèle et voulez libérer les ressources immédiatement

Note : Le paramètre keep_alive contrôle combien de temps (en secondes) un modèle reste chargé en mémoire après la dernière requête. Le régler sur 0 décharge immédiatement le modèle de la VRAM.

Si vous préférez éviter complètement la couche d’abstraction d’Ollama et voulez un contrôle direct sur quel modèle GGUF est résident à tout moment, mode routeur de llama-server couvre l’approche native llama.cpp pour le basculement dynamique de modèles.

Personnalisation des modèles Ollama (prompt système, Modelfile)

• Définir le prompt système : Dans le REPL Ollama, vous pouvez définir un prompt système pour personnaliser le comportement du modèle :

  >>> /set system Pour toutes les questions posées, répondez en anglais simple en évitant le jargon technique autant que possible
  >>> /save ipe
  >>> /bye
  

  Ensuite, exécutez le modèle personnalisé :

  ollama run ipe
  

  Cela définit un prompt système et enregistre le modèle pour une utilisation future.

• Créer un fichier de modèle personnalisé : Créez un fichier texte (par exemple, custom_model.txt) avec la structure suivante :

  FROM llama3.1
  SYSTEM [Vos instructions personnalisées ici]
  

  Ensuite, exécutez :

  ollama create mymodel -f custom_model.txt
  ollama run mymodel
  

  Cela crée un modèle personnalisé basé sur les instructions du fichier.

Ollama signin et signout (authentification du registre)

ollama signin
ollama signout

ollama signin authentifie votre installation locale Ollama auprès du registre Ollama à ollama.com. Une fois connecté, le client stocke les identifiants localement et les réutilise automatiquement pour les commandes ultérieures.

Ce que signin débloque :

• Récupération et téléversement de modèles privés depuis votre compte ou organisation.
• Utilisation de modèles hébergés dans le cloud (par exemple qwen3-coder:480b-cloud) qui sont trop grands pour s’exécuter localement.
• Publication de modèles vers le registre avec ollama push.

Alternative : authentification par clé API

Si vous exécutez Ollama dans une pipeline CI ou un serveur headless où ollama signin interactif n’est pas pratique, créez une clé API dans les paramètres de votre compte Ollama et exposez-la comme une variable d’environnement :

export OLLAMA_API_KEY=ollama_...
ollama pull myorg/private-model

La variable OLLAMA_API_KEY est récupérée automatiquement par chaque commande Ollama et requête API — pas besoin d’exécuter ollama signin sur chaque machine.

Utilisation de la commande Ollama run avec des fichiers (résumé, redirection)

• Résumer du texte depuis un fichier :

  ollama run llama3.2 "Résumez le contenu de ce fichier en 50 mots." < input.txt
  

  Cette commande résume le contenu de input.txt en utilisant le modèle spécifié.

• Enregistrer les réponses du modèle dans un fichier :

  ollama run llama3.2 "Parlez-moi des énergies renouvelables." > output.txt
  

  Cette commande enregistre la réponse du modèle dans output.txt.

Cas d’utilisation de la CLI Ollama (génération de texte, analyse)

• Génération de texte :

  • Résumer un fichier texte volumineux :

    ollama run llama3.2 "Résumez le texte suivant :" < long-document.txt
    

  • Générer du contenu :

    ollama run llama3.2 "Écrivez un court article sur les avantages de l'utilisation de l'IA dans les soins de santé." > article.txt
    

  • Répondre à des questions spécifiques :

    ollama run llama3.2 "Quelles sont les dernières tendances en IA, et comment elles affecteront les soins de santé ?"
    

  .

• Traitement et analyse de données :

  • Classer le texte en sentiment positif, négatif ou neutre :

    ollama run llama3.2 "Analysez le sentiment de cette critique client : 'Le produit est fantastique, mais la livraison était lente.'"
    

  • Catégoriser le texte dans des catégories prédéfinies : Utilisez des commandes similaires pour classer ou catégoriser le texte selon des critères prédéfinis.

Utilisation d’Ollama avec Python (client et API)

• Installer la bibliothèque Python Ollama :

  pip install ollama
  

• Générer du texte en utilisant Python :

  import ollama
  
  response = ollama.generate(model='gemma:2b', prompt='qu'est-ce qu'un qubit ?')
  print(response['response'])
  

  Ce snippet de code génère du texte en utilisant le modèle et le prompt spécifiés.

Pour une intégration Python avancée, explorez l’utilisation de l’API de recherche web d’Ollama en Python, qui couvre les capacités de recherche web, l’appel d’outils et l’intégration de serveurs MCP. Si vous construisez des applications alimentées par l’IA, notre comparaison d’assistants de codage IA peut vous aider à choisir les bons outils pour le développement.

Vous cherchez une interface web ? Open WebUI fournit une interface auto-hébergée avec des capacités RAG et un support multi-utilisateurs. Pour les déploiements de production à haute performance, envisagez vLLM comme alternative. Pour comparer Ollama avec d’autres choix d’infrastructure LLM locaux et cloud, consultez Hébergement LLM : Comparaison des infrastructures locales, auto-hébergées et cloud.

Liens utiles

Configuration et gestion

• Déplacer les modèles Ollama vers un autre lecteur ou dossier

Alternatives et comparaisons

• Hébergement LLM local : Guide complet 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio & Plus
• Démarrage rapide vLLM : Service LLM haute performance
• Docker Model Runner vs Ollama : Lequel choisir ?
• Premiers signes de la dégradation d’Ollama

Performance et matériel

• Comment Ollama gère les requêtes parallèles
• Comment Ollama utilise les cœurs de performance et efficaces des CPU Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080 : Comparaison des performances Ollama
• DGX Spark vs Mac Studio : Regard pratique et vérifié des prix sur le supercalculateur personnel IA de NVIDIA

Intégration et développement

• Utilisation de l’API de recherche web d’Ollama en Python
• Comparaison des assistants de codage IA
• Open WebUI : Interface LLM auto-hébergée
• Interfaces de chat open-source pour les LLM sur les instances locales Ollama
• Contrainte des LLM avec une sortie structurée : Ollama, Qwen3 & Python ou Go
• Intégration d’Ollama avec Python : Exemples REST API et client Python
• SDKs Go pour Ollama - comparaison avec des exemples