Ollama CLI Cheatsheet : ls, serve, run, ps et commandes (mise à jour 2026)

Cette Aide-mémoire CLI Ollama se concentre sur les commandes que vous utilisez au quotidien (ollama ls, ollama serve, ollama run, ollama ps, la gestion des modèles et les flux de travail courants), avec des exemples que vous pouvez copier/coller.

Il inclut également la référence complète des variables d’environnement ollama serve (OLLAMA_NUM_PARALLEL, OLLAMA_CONTEXT_LENGTH, OLLAMA_KV_CACHE_TYPE et leurs homologues), les drapeaux des modèles de raisonnement (--think, --hidethinking), et les intégrations étendues de ollama launch pour les assistants de codage IA. Les commandes et drapeaux ci-dessous ont été vérifiés par rapport à Ollama v0.33.2 (octobre 2026).

Cet aide-mémoire Ollama se concentre sur les commandes CLI, la gestion des modèles et la personnalisation, mais inclut également quelques appels curl.

Pour une vue d’ensemble complète 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 de LLM : comparaison des infrastructures locales, auto-hébergées et cloud. Si vous comparez différentes solutions d’hébergement local de LLM, découvrez notre comparaison complète d’Ollama, vLLM, LocalAI, Jan, LM Studio et d’autres. 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. Si le trafic concurrent ou la mise en file d’attente commence à mettre à rude épreuve une instance Ollama unique, Ollama vers vLLM : quand migrer votre serveur local de LLM détaille les signaux de migration et un plan de déploiement progressif.

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

• Option 1 : Téléchargement depuis le site web
  • Visitez ollama.com et téléchargez l’installeur 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 saisissez votre mot de passe si demandé.

Exigences système d’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èles peuvent être vraiment gros — voir la section gestion des modèles ci-dessous pour les déplacer)
• Processeur : Un CPU relativement moderne (de moins de 5 ans). Si vous êtes curieux de savoir comment Ollama utilise différentes architectures CPU, consultez notre analyse de comment Ollama utilise les cœurs de performance et d’efficacité des CPU Intel.

Commandes de base de la CLI Ollama

L’exécution simple de ollama sans arguments ouvre désormais le même menu de lancement interactif que ollama launch — vous choisissez une intégration et un modèle depuis une liste.

CLI Ollama (ce que c’est)

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

• Démarrer le serveur : ollama serve
• Exécuter un modèle : ollama run <modele>
• Voir ce qui est chargé/en cours d’exécution : ollama ps
• Gérer les modèles : ollama pull, ollama list, ollama rm
• Lancer un assistant de codage IA : ollama launch

Gestion des modèles Ollama : commandes pull et list

Liste des 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, par exemple :

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

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 ex., Gemma 2B, ou mistral-nemo:12b-instruct-2407-q6_K) sur votre système. Les fichiers de modèles peuvent être assez volumineux, alors surveillez l’espace utilisé par les modèles sur le disque dur, ou le ssd. Vous voudrez peut-être même déplacer tous les modèles Ollama de votre répertoire personnel vers un autre disque plus grand et plus performant.

Envoyer un modèle : ollama push

ollama push my-custom-model

Envoie un modèle local au registre Ollama afin que d’autres puissent le télécharger. Vous devez d’abord être connecté (ollama signin) et le nom du modèle doit être préfixé par votre nom d’utilisateur Ollama, par ex. myuser/my-model. Utilisez --insecure si vous envoyez 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 retélécharger. C’est pratique avant d’éditer 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

Supprimer des modèles : ollama rm

ollama rm qwen3:8b
# les versions plus récentes acceptent plusieurs modèles dans un seul appel :
ollama rm qwen3:8b qwen3:14b

ollama rm supprime le manifeste du modèle et tous les blobs qui ne sont plus référencés par d’autres modèles, de sorte que les couches de base partagées des modèles dérivés sont conservées.

Commande Ollama show

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

ollama show qwen3:14b

Par défaut, il imprime la carte du modèle (architecture, longueur de contexte, longueur d’embedding, quantification, etc.). Il y a six drapeaux utiles :

# Voir exactement quel prompt système et quel gabarit le modèle a été construit avec
ollama show deepseek-r1:8b --modelfile

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

# Juste le prompt système d'un modèle personnalisé
ollama show mymodel --system

# Vérifier la licence avant d'expédier un modèle dans un produit
ollama show llama3.2 --license

# Détails complets au niveau des tenseurs (utile lors du débogage de la quantification)
ollama show llama3.2 --verbose

La sortie de --modelfile est particulièrement utile avant de personnaliser un modèle : vous pouvez copier le Modelfile de base et éditer à partir de là plutôt que d’en écrire un 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

ollama start est un alias pour ollama serve, donc les deux démarrent le même serveur.

Le bind à 0.0.0.0 expose le serveur à votre réseau sans authentification — placez un reverse proxy avec TLS devant, comme décrit dans Ollama derrière un reverse proxy avec Caddy ou Nginx, ou accédez-y via un tunnel privé en suivant les schémas d’accès distant Ollama. Pour exécuter le serveur dans un conteneur à la place, voir Ollama dans Docker Compose avec GPU et stockage persistant des modèles.

Variables d’environnement Ollama serve (référence complète)

Ce sont les variables d’environnement que ollama serve lit au démarrage (à partir de Ollama v0.33) :

Par exemple, pour augmenter la fenêtre de contexte par défaut pour chaque modèle :

OLLAMA_CONTEXT_LENGTH=32768 ollama serve

Longueur de contexte par défaut selon la VRAM

Lorsque OLLAMA_CONTEXT_LENGTH n’est pas défini, le serveur choisit une valeur par défaut graduée basée sur la VRAM totale de votre machine (ajouté dans Ollama v0.15.5) :

Ollama recommande au moins 64 000 jetons pour les charges de travail gourmandes en contexte — recherche web, agents et outils de codage — et l’empreinte mémoire augmente avec OLLAMA_NUM_PARALLEL, donc un réglage de parallélisme élevé combiné à un contexte par défaut important peut chasser les couches du modèle hors de la VRAM. Le serveur journalise la valeur choisie comme vram-based default context au démarrage.

Le type de cache KV échange la mémoire contre la vitesse — quantifier le cache KV en q8_0 divise approximativement son empreinte VRAM par deux et convient aux exécutions à long contexte ; notre test de cache KV sur un GPU 16GB long-context mesure l’effet réel. OLLAMA_NUM_PARALLEL et OLLAMA_MAX_QUEUE sont couverts en détail dans Comment Ollama gère les requêtes parallèles.

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 souhaitez comprendre comment Ollama gère plusieurs requêtes concurrentes ? En savoir plus sur comment 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, ainsi, dans le cas de gpt-oss:120b, vous verriez quelque chose comme

$ 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 es-tu ?
Réflexion...
L'utilisateur demande "qui es-tu ?" Question simple. Devrait répondre en tant que ChatGPT, un modèle de langue IA, entraîné par OpenAI,
etc. Fournir une brève introduction. Probablement demander s'ils ont besoin d'aide.
...fin de la réflexion.

Je suis ChatGPT, un modèle de langue IA créé par OpenAI. J'ai été entraîné sur une large gamme de textes, de sorte que je peux aider
à répondre aux questions, brainstormner des idées, expliquer des concepts, rédiger des textes, dépanner des problèmes et bien plus. Pensez
à moi comme à un assistant virtuel polyvalent — ici pour fournir des informations, un soutien et des conversations chaque fois que vous en avez
besoin. Comment puis-je vous aider aujourd'hui ?

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

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

>>> /bye
$ 

Exemples de la commande Ollama run

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

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

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

$ ollama run gpt-oss:20b --verbose
>>> qui es-tu ?
Réflexion...
Nous devons répondre à une question simple : "qui es-tu ?" L'utilisateur demande "qui es-tu ?" Nous pouvons répondre que nous sommes
ChatGPT, un grand modèle de langue entraîné par OpenAI. Nous pouvons également mentionner les capacités. L'utilisateur s'attend probablement
à une brève introduction. Nous le garderons convivial.
...fin de la réflexion.

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

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

Oui, c’est exact, c’est 139 jetons par seconde. gpt-oss:20b est très rapide. Si, comme moi, vous avez un GPU avec 16 Go de VRAM, consultez les détails de la 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 au lieu de longues sessions interactives.

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

Deux variables d’environnement affectent ollama run lui-même : OLLAMA_EDITOR définit l’éditeur ouvert par Ctrl+G dans le REPL, et OLLAMA_NOHISTORY=1 désactive la persistance de l’historique readline.

Modèles de réflexion : –think et –hidethinking

Les modèles capables de réflexion (deepseek-r1, qwen3, gpt-oss et leurs homologues) réfléchissent par défaut dans la CLI, et la trace de raisonnement est imprimée avant la réponse :

ollama run qwen3:14b --think=false "Réponds directement, pas de trace de raisonnement"
ollama run deepseek-r1:8b --hidethinking "Est-ce que 9.9 est plus grand que 9.11 ?"   # réfléchit, mais n'imprime que la réponse

Les modèles GPT-OSS acceptent des niveaux au lieu d’un booléen — ils ajustent la longueur de la trace plutôt que de l’activer ou de la désactiver :

ollama run gpt-oss:20b --think=low "Rédiger un titre"

Dans la session interactive, basculez la réflexion avec /set think et /set nothink.

Remplacement des paramètres de modèle sans Modelfile

Les anciens articles de blog montrent un drapeau -p / --parameters sur ollama run ; il n’existe plus dans les versions actuelles. La méthode prise en charge pour changer les paramètres d’inférence sans modifier un Modelfile est le REPL :

$ ollama run qwen3:14b
>>> /set parameter num_ctx 32768
Paramètre 'num_ctx' défini à '32768'
>>> /save qwen3-14b-32k
>>> /bye

/set parameter s’applique uniquement à la session actuelle, et /save le persiste dans un nouveau modèle local que vous pouvez exécuter plus tard avec ollama run qwen3-14b-32k. /show parameters liste les paramètres dans la session actuelle. Pour tous les modèles sur un serveur, OLLAMA_CONTEXT_LENGTH sur ollama serve change la fenêtre de contexte par défaut globalement.

Paramètres courants que vous pouvez définir de cette manière :

ollama show <modele> rapporte la longueur du contexte que le modèle peut supporter, tandis que ollama ps affiche le contexte réellement alloué pour l’instance chargée — voir Commande Ollama ps si un long prompt semble être tronqué silencieusement.

Saisie multi-lignes dans le REPL

Enveloppez le texte dans des guillemets triples (""") pour saisir un prompt multi-lignes sans soumettre prématurément :

>>> """Résume ceci en une phrase :
... Le rapide renard brun saute par-dessus le chien paresseux.
... C'est arrivé un mardi.
... """

Pour les prompts plus longs, Ctrl+G ouvre le prompt actuel dans un éditeur de texte complet ($EDITOR, ou tout ce vers quoi pointe OLLAMA_EDITOR) et le soumet lorsque vous enregistrez et quittez — pratique pour itérer sur un long prompt de style système (ajouté dans Ollama v0.16).

Modèles multimodaux (images)

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

ollama run gemma3 "Que contient cette image ? /home/user/screenshot.png"

Génération d’embeddings via la CLI

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

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

Deux drapeaux ollama run sont spécifiques aux modèles d’embedding : --dimensions 512 tronque le vecteur de sortie à 512 dimensions (utile pour les modèles compatibles Matryoshka comme nomic-embed lorsque vous voulez des vecteurs plus petits), et --truncate=false fait que les entrées plus longues que le contexte du modèle renvoient une erreur au lieu d’être tronquées silencieusement.

Pour les charges de travail d’embedding en production, utilisez le point d’accès REST /api/embed ou le client Python à la place.

Forcer la sortie JSON (–format)

ollama run llama3.2 --format json "Liste 5 capitales en JSON"

Le modèle est instruit de renvoyer un 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 en cours d’exécution spécifié.

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

Ollama évacue automatiquement les modèles après un certain temps. La valeur par défaut est de 5 minutes (OLLAMA_KEEP_ALIVE=5m) ; les anciennes versions d’Ollama utilisaient 4 minutes. Si vous ne voulez pas attendre le temps restant, utilisez la commande ollama stop. Lors du démarrage du modèle, vous pouvez également passer --keepalive à ollama run (par ex. --keepalive 30s, --keepalive -1 pour garder le modèle chargé indéfiniment), ou appeler le point d’accès API /generate avec le paramètre keep_alive=0 pour expulser immédiatement le modèle de la VRAM — 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

L’exemple de sortie de ollama ps est ci-dessous :

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

La colonne CONTEXT est le contexte réellement alloué pour cette instance chargée. Il diffère de ollama show <modele>, qui rapporte la longueur du contexte que le modèle prend en charge — si un modèle tronque silencieusement vos prompts longs, ollama ps est la commande qui révèle la valeur réelle d’exécution.

Vous voyez ici sur mon PC que gpt-oss:20b tient très bien dans les 16 Go de VRAM de mon GPU, et n’occupe que 14 Go.

Si j’exécute ollama run gpt-oss:120b puis j’appelle ollama ps, le résultat ne sera pas aussi brillant : 78 % des couches sont sur le CPU, et ce n’est qu’avec la fenêtre de contexte de 4096 jetons — l’empreinte mémoire augmente davantage si j’augmente le contexte.

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

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 seule ligne, pour les assistants de codage IA populaires fonctionnant 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 définir manuellement des variables d’environnement, pointer l’outil vers le bon point d’accès 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 agentique sans payer d’appels API ou envoyer votre code dans le cloud, ollama launch est le chemin le plus rapide.

Intégrations prises en charge

La liste s’est considérablement élargie au-delà des quatre intégrations de v0.15. À partir de Ollama v0.33, ollama launch prend en charge :

Utilisation de base

# Sélecteur interactif — choisissez une intégration et un modèle depuis un menu
# (le sélecteur de modèle est toujours affiché depuis v0.16.3)
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

# Réinitialiser une intégration à son profil par défaut
ollama launch codex --restore

# Passer des arguments supplémentaires à l'intégration après --
ollama launch codex -- --sandbox workspace-write

--yes (-y) répond automatiquement aux invites de confirmation, ce qui est utile dans les scripts et les flux d’adoption.

Modèles recommandés

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

Si votre GPU ne peut pas contenir le modèle, Ollama offre également des variantes hébergées dans le cloud (par ex. qwen3-coder:480b-cloud) qui s’intègrent de la même manière mais routent l’inférence vers le niveau 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. Lancez 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 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.

Réglages de performance (OLLAMA_NUM_PARALLEL)

Si vous voyez des mises en file d’attente ou des dépassements de délai sous charge, le premier réglage à 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.
• Les requêtes qui arrivent pendant que tous les slots parallèles sont occupés atterrissent dans la file d’attente ; sa profondeur est limitée par OLLAMA_MAX_QUEUE.

Exemple rapide :

OLLAMA_NUM_PARALLEL=2 ollama serve

Pour une explication complète (y compris les stratégies d’ajustement et les modes de défaillance), voir :

• 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 avez 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 un modèle de la VRAM en utilisant curl :

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

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

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

• Libérer un 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}
)

Cela est particulièrement utile lorsque :

• Vous avez besoin de libérer 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 pendant combien de temps (en secondes) un modèle reste chargé en mémoire après la dernière requête. Le définir à 0 décharge immédiatement le modèle de la VRAM, une valeur négative (par ex. -1) garde le modèle chargé indéfiniment, et une chaîne de durée (par ex. 10m, 24h) est également acceptée. La valeur par défaut globale du serveur est OLLAMA_KEEP_ALIVE=5m, et un keep_alive par requête le remplace toujours.

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

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éponds 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 ex., custom_model.txt) avec la structure suivante :

  FROM llama3.1
  PARAMETER num_ctx 32768
  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 dans le fichier. ollama create peut également quantifier pendant la construction — -q q4_K_M produit un GGUF Q4_K_M à partir d’une source non quantifiée (safetensors), --draft-quantize définit la quantification pour un modèle de brouillon (décodage spéculatif), et --experimental active les fonctionnalités de création de modèles safetensors encore marquées comme expérimentales.

Ollama signin et signout (authentification du registre)

ollama signin
ollama signout

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

Ce que signin débloque :

• Téléchargement et envoi de modèles privés de votre compte ou organisation.
• Utilisation de modèles hébergés dans le cloud (par ex. qwen3-coder:480b-cloud) qui sont trop grands pour s’exécuter localement.
• Publication de modèles au registre avec ollama push.

Alternative : authentification par clé API

Si vous exécutez Ollama dans un pipeline CI ou un serveur sans interface où ollama signin interactif n’est pas pratique, créez une clé API dans les paramètres de votre compte Ollama et exposez-la en tant que 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 et requête API Ollama — pas besoin d’exécuter ollama signin sur chaque machine.

Utilisation de la commande Ollama run avec des fichiers (résumer, rediriger)

• Résumer du texte depuis un fichier :

  ollama run llama3.2 "Résume 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é.

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

  ollama run llama3.2 "Parle-moi de l'énergie renouvelable." > 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ésumé d’un grand fichier texte :

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

  • Génération de contenu :

    ollama run llama3.2 "Écris 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 dans l'IA, et comment affecteront-elles les soins de santé ?"
    

  • Réponses en une seule fois sans trace de réflexion (sur les modèles de réflexion) :

    ollama run qwen3:14b --think=false --hidethinking "Quelles sont les dernières tendances dans l'IA, et comment affecteront-elles les soins de santé ?"
    

• Traitement et analyse de données :

  • Classification du texte en sentiment positif, négatif ou neutre :

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

  • Catégorisation du texte dans des catégories prédéfinies : Utilisez des commandes similaires pour classifier ou catégoriser le texte sur la base de 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 fragment 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, les appels d’outils et l’intégration du serveur MCP.

Vous cherchez une interface basée sur le web ? Open WebUI fournit une interface auto-hébergée avec des capacités RAG et un support multi-utilisateurs.

Liens utiles

Configuration et Gestion

• Déplacer les modèles Ollama vers un autre disque ou dossier
• Ollama dans Docker Compose avec GPU et stockage persistant des modèles

Alternatives et Comparaisons

• Hébergement local de LLM : Guide complet 2026 - Ollama, vLLM, LocalAI, Jan, LM Studio et d’autres
• llama.cpp vs Ollama en 2026 : quel runtime devez-vous exécuter ?
• Démarrage rapide vLLM : Servie de LLM à haute performance
• Docker Model Runner vs Ollama : lequel choisir ?
• Premiers signes de l’enshittification d’Ollama
• Ollama vers vLLM : quand migrer votre serveur local de LLM

Performance et Matériel

• Comment Ollama gère les requêtes parallèles
• Comment Ollama utilise les cœurs de performance et d’efficacité des CPU Intel
• NVIDIA DGX Spark vs Mac Studio vs RTX-4080 : Comparaison de performance Ollama

Intégration et Développement

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