Aller au contenu
EN 4 QUESTIONSTrouver mon modèle
Code · guide expert · 25 min de lecture

Brancher Ollama dans un agent de code

Un agent de code peut réfléchir avec un modèle qui tourne sur votre machine, sans abonnement et sans que le code sorte de chez vous. Voici les réglages d'Ollama et de chaque agent, et ce qu'il faut en attendre.

Illustration du thème Code

Un agent de code se compose de deux pièces : le programme qui lit vos fichiers et lance les commandes, et le modèle qui décide quoi faire. La seconde peut tourner sur votre machine. Ollama sert alors le modèle sur une adresse locale, et l’agent lui envoie ses requêtes comme il le ferait à Anthropic ou OpenAI. Le code ne quitte pas l’ordinateur, il n’y a pas d’abonnement, et l’agent marche sans connexion.

Comment ça marche

L'agent envoie ses requêtes à Ollama sur la machine même (localhost, port 11434) ; Ollama fait tourner le modèle et renvoie la réponse, sans passer par Internet.

Ollama lance sur votre machine un petit serveur, joignable à l’adresse http://localhost:11434. Il parle deux langues : celle de l’API d’OpenAI (sous /v1) et celle de l’API d’Anthropic. Un agent de code qui sait viser une autre adresse que celle de son éditeur peut donc s’y brancher, en lui demandant le nom du modèle local à utiliser.

À quoi ça sert

  • Un code confidentiel : un projet client, des données internes, rien ne doit partir chez un fournisseur.
  • Travailler sans connexion : dans le train ou en avion, l’agent continue avec le modèle local.
  • Les petites tâches répétitives : renommer, documenter, écrire des tests simples, sans consommer d’abonnement.
  • Apprendre et essayer sans compte ni carte bancaire.

Il faut accepter un écart de niveau. Les meilleurs modèles qui tiennent sur un ordinateur restent derrière les meilleurs modèles en ligne pour le code : comparez le classement Code et celui des modèles locaux. Avec le même programme, un modèle plus modeste réussit moins de tâches. Pour une routine, un script ou un projet sensible, le compromis se tient très bien.

Les étapes en résumé

  1. Installez Ollama depuis sa page de téléchargement, ou sous Linux avec curl -fsSL https://ollama.com/install.sh | sh.
  2. Choisissez un modèle qui sait appeler des outils et qui tient dans votre mémoire, puis téléchargez-le avec ollama pull.
  3. Réglez le contexte sur 64 000 jetons au moins.
  4. Vérifiez avec ollama ps que le modèle tient entièrement sur la carte graphique.
  5. Lancez l’agent sur Ollama : ollama launch suivi du nom de l’agent, ou par son fichier de réglages.
  6. Dans l’agent, vérifiez qu’il parle bien au modèle local (/status dans Claude Code) avant de lui confier une tâche.

Choisir un modèle qui sait se servir d’outils

Un agent de code demande au modèle d’appeler des outils : lire un fichier, l’écrire, lancer une commande. Tous les modèles ne savent pas le faire. La documentation d’Ollama demande un modèle de la catégorie « tools » (filtre ?c=tools sur ollama.com/search), et les meilleurs d’entre eux selon la mémoire de votre machine sont ci-dessous.

Les meilleurs modèles pour une machine de 32 Go

  1. Qwen 3.8 27Ballégée à 4 bits, 18,6 Goscore 83,1
  2. Gemma 4 31B ITallégée à 4 bits, 21,4 Goscore 75,5
  3. Qwen3.6 27Ballégée à 4 bits, 19,2 Goscore 75,5
  4. Muse Glimmerallégée à 4 bits, 20,7 Goscore 73,9
  5. Gemma 4 26B A4Ballégée à 4 bits, 17,9 Goscore 73,1

Mémoire utile retenue : 30 Go, celle des machines suivies de 32 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.

Quel modèle sur ma machine →Les modèles qui tournent en local →

Les meilleurs modèles pour une machine de 128 Go

  1. Qwen 3.8 27Bcomplète, 62,1 Goscore 83,1
  2. Nemotron 3.5 Super VLallégée à 4 bits, 82,8 Goscore 76,1
  3. Gemma 4 31B ITcomplète, 71,3 Goscore 75,5
  4. Qwen3.6 27Bcomplète, 63,9 Goscore 75,5
  5. Muse Glimmercomplète, 69 Goscore 73,9

Mémoire utile retenue : 112 Go, celle des machines suivies de 128 Go. Score IA de l'édition du 16 novembre 2026, version la plus complète qui tient.

Quel modèle sur ma machine →Les modèles qui tournent en local →

Téléchargez le modèle choisi avec ollama pull, suivi de son nom tel qu’Ollama l’écrit. Les exemples de ce guide reprennent qwen3.5, le modèle des exemples d’Ollama : remplacez-le par le vôtre.

Régler le contexte avant toute chose

Le contexte est la quantité de texte que le modèle garde en tête : vos consignes, les fichiers lus, les résultats des commandes. Un agent en consomme beaucoup. Ollama recommande au moins 64 000 jetons pour les agents et les outils de code, et l’intégration d’OpenCode en fait une condition.

Par défaut, Ollama règle le contexte selon la mémoire graphique : 4 000 jetons sous 24 Gio, 32 000 de 24 à 48 Gio, 256 000 au-delà. Sur une petite machine, le défaut est donc trop bas pour un agent. Sur une grosse, il peut être bien plus haut que nécessaire, et chaque jeton de contexte réserve de la mémoire.

Fixez-le vous-même. En lançant le serveur à la main :

OLLAMA_CONTEXT_LENGTH=64000 ollama serve

Sous Linux, quand Ollama tourne comme service, sudo systemctl edit ollama ouvre un fichier de surcharge. Ajoutez-y ces deux lignes, puis redémarrez le service :

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=64000"

Sur Mac, l’application Ollama lit launchctl setenv OLLAMA_CONTEXT_LENGTH 64000 (redémarrez l’application ensuite). Sous Windows, quittez Ollama, ajoutez la variable dans les variables d’environnement de votre compte, puis relancez-le. L’application propose aussi un curseur de contexte dans ses réglages.

Vérifiez ensuite avec ollama ps, qui liste les modèles chargés en mémoire.

Terminal : ollama --version répond 0.21.1, puis ollama ps affiche l'en-tête NAME, ID, SIZE, PROCESSOR, CONTEXT, UNTIL sans aucune ligne.
Sortie réelle relevée le 17 novembre 2026 sur le mini-PC de QUELLE IA, où Ollama tourne dans son conteneur Docker officiel : aucun modèle n'est chargé à ce moment, mais les colonnes CONTEXT et PROCESSOR sont celles à surveiller.

La colonne CONTEXT montre la valeur retenue, et la colonne PROCESSOR doit afficher 100% GPU. Si une partie du modèle passe sur le processeur, il sera beaucoup plus lent : réduisez le contexte ou prenez un modèle plus petit.

Bon à savoir : Ollama décharge un modèle cinq minutes après la dernière requête. Un agent qui réfléchit longtemps entre deux appels le recharge alors à chaque fois. La variable OLLAMA_KEEP_ALIVE allonge ce délai.

Claude Code

Ollama sait parler le format de l’API d’Anthropic, et la commande ollama launch fait tout le branchement :

ollama launch claude

Elle vous laisse choisir le modèle puis ouvre Claude Code dessus. Pour un script, ajoutez le modèle et --yes (les arguments après -- vont à Claude Code) :

ollama launch claude --model qwen3.5 --yes -- -p "Comment fonctionne ce dépôt ?"

À la main, trois variables suffisent le temps d’une session :

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3.5

Les réglages de Claude Code peuvent l’emporter sur ces variables : tapez /status dans la session pour vérifier qu’il parle bien à Ollama. La documentation d’Ollama prévient aussi que la recherche web hébergée et certains contrôles avancés des outils ne marchent pas complètement.

Codex

ollama launch codex

Ollama prépare un profil Codex dédié et lance la session. ollama launch codex --config crée le profil sans lancer Codex, et --restore le retire. Sans passer par Ollama, l’option --oss de Codex suffit :

codex --oss -m qwen3.5

Pour un réglage durable, la documentation d’Ollama décrit un profil dans ~/.codex/ollama-launch.config.toml, lancé ensuite avec codex --profile ollama-launch :

model = "qwen3.5"
model_provider = "ollama-launch"
model_catalog_json = "/Users/vous/.codex/model.json"   # catalogue des modèles, à adapter à votre dossier personnel

[model_providers.ollama-launch]
name = "Ollama"
base_url = "http://localhost:11434/v1/"
wire_api = "responses"

Là encore, Ollama demande au moins 64 000 jetons de contexte.

OpenCode

OpenCode est un agent de code open source, conçu pour accepter n’importe quel fournisseur, local compris.

Installer OpenCode

macOS et Linux · macOS, Linux (script)

curl -fsSL https://opencode.ai/v2/install | bash

Homebrew · macOS, Linux (Homebrew)

brew install anomalyco/tap/opencode-v2

D'après opencode.ai, lue le 3 octobre 2026.La fiche de OpenCode →

Le plus court reste ollama launch opencode. La commande lance OpenCode avec une configuration en ligne pour le modèle choisi, sans réécrire votre fichier ~/.config/opencode/opencode.json : vos autres réglages restent en place.

Pour un branchement permanent, déclarez Ollama comme fournisseur dans ce fichier. Il passe par le paquet @ai-sdk/openai-compatible, avec l’adresse http://localhost:11434/v1 et la liste de vos modèles :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3.5": {
          "name": "qwen3.5"
        }
      }
    }
  }
}

Ce bloc suit l’écriture de la version 1 d’OpenCode, que la version 2 lit toujours. La version 2 trouve aussi seule les modèles d’Ollama à son adresse par défaut : "model": "ollama/qwen3.5" suffit alors. Le reste des réglages (agents, permissions, serveurs MCP) est décrit dans Configurer OpenCode.

Mistral Vibe

Vibe accepte tout serveur qui suit l’API d’OpenAI, à condition qu’il renvoie la consommation de jetons dans ses réponses en flux (stream_options.include_usage). L’interface compatible d’Ollama le fait et accepte les outils, d’après sa documentation. L’exemple de Mistral vise un serveur vLLM sur le port 8080 ; pour Ollama, on garde la même forme et on change l’adresse.

  1. Notez le nom exact du modèle avec ollama list.
  2. Ouvrez ~/.vibe/config.toml (ou le .vibe/config.toml d’un projet, lu seulement si vous faites confiance au dossier).
  3. Ajoutez un fournisseur et un modèle :
active_model = "local"

[[providers]]
name = "ollama"
api_base = "http://localhost:11434/v1"
api_style = "openai"
backend = "generic"

[[models]]
name = "qwen3.5"
provider = "ollama"
alias = "local"
max_context_length = 64000
  1. Gardez active_model au-dessus du premier tableau, sinon TOML le range dans ce tableau.
  2. Réglez max_context_length sur le contexte choisi dans Ollama : Vibe ne connaît pas ce modèle et ne peut pas le deviner.
  3. Lancez vibe. Dans la session, /config change de modèle.

Mistral conseille ses propres modèles ouverts pour cet usage, Devstral Small 2 et Mistral Small 4.

Gemini CLI

Gemini CLI ne décrit officiellement que les modèles Gemini de Google. Pour un agent de code sur un modèle local, prenez l’un des quatre outils ci-dessus.

Garder Ollama chez vous

Ollama écoute par défaut sur 127.0.0.1:11434, c’est-à-dire sur la machine seule. Sa documentation ne décrit aucune authentification sur ce serveur local. Si vous changez OLLAMA_HOST pour le rendre joignable depuis un autre appareil, faites-le derrière un réseau privé (un VPN comme Tailscale). N’ouvrez jamais le port sur Internet : quiconque le trouverait pourrait se servir de votre carte graphique.

Rappelez-vous enfin que l’agent garde tous ses pouvoirs avec un modèle local. Il lit vos fichiers et lance des commandes, avec un modèle qui se trompe plus souvent. Laissez les demandes d’autorisation activées et relisez chaque modification avant de l’accepter.

Pour aller plus loin

Sur mini lab AI, un guide du même auteur reprend ce sujet pour monter son atelier d'IA à la maison.

Tous les guides →

Sources

  1. docs.ollama.com, lue le
  2. docs.ollama.com, lue le
  3. docs.ollama.com, lue le
  4. opencode.ai, lue le
  5. docs.ollama.com, lue le
  6. docs.ollama.com, lue le
  7. docs.ollama.com, lue le
  8. docs.ollama.com, lue le
  9. docs.ollama.com, lue le
  10. docs.mistral.ai, lue le
  11. docs.mistral.ai, lue le