# Brancher Ollama dans un agent de code

> Faire tourner Claude Code, Codex, OpenCode ou Mistral Vibe sur un modèle local servi par Ollama : contexte, commandes, réglages et limites à connaître.

- Niveau : Expert
- Thème : Code
- Durée : 25 minutes
- Systèmes : Mac, Windows, Linux
- Publié le 17 novembre 2026, relu le 17 novembre 2026
- Auteur : Ulrich Rozier
- Page : https://quelleia.com/guides/agent-de-code-avec-un-modele-local/

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.](https://quelleia.com/guides/agent-de-code-avec-un-modele-local/agent-ollama-local.svg)

*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](https://quelleia.com/classement/code/) et celui des [modèles locaux](https://quelleia.com/classement/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](https://quelleia.com/logitheque/ollama/), 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 27B](https://quelleia.com/modeles/qwen-3-8-27b/) : score 83,1 (allégée à 4 bits, 18,6 Go)
2. [Gemma 4 31B IT](https://quelleia.com/modeles/gemma-4-31b-it/) : score 75,5 (allégée à 4 bits, 21,4 Go)
3. [Qwen3.6 27B](https://quelleia.com/modeles/qwen3-6-27b/) : score 75,5 (allégée à 4 bits, 19,2 Go)
4. [Muse Glimmer](https://quelleia.com/modeles/muse-glimmer/) : score 73,9 (allégée à 4 bits, 20,7 Go)
5. [Gemma 4 26B A4B](https://quelleia.com/modeles/gemma-4-26b-a4b/) : score 73,1 (allégée à 4 bits, 17,9 Go)

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](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

**Les meilleurs modèles pour une machine de 128 Go**

1. [Qwen 3.8 27B](https://quelleia.com/modeles/qwen-3-8-27b/) : score 83,1 (complète, 62,1 Go)
2. [Nemotron 3.5 Super VL](https://quelleia.com/modeles/nemotron-3-5-super-vl/) : score 76,1 (allégée à 4 bits, 82,8 Go)
3. [Gemma 4 31B IT](https://quelleia.com/modeles/gemma-4-31b-it/) : score 75,5 (complète, 71,3 Go)
4. [Qwen3.6 27B](https://quelleia.com/modeles/qwen3-6-27b/) : score 75,5 (complète, 63,9 Go)
5. [Muse Glimmer](https://quelleia.com/modeles/muse-glimmer/) : score 73,9 (complète, 69 Go)

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](https://quelleia.com/local/)
[Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)

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 :

```bash
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 :

```ini
[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.](https://quelleia.com/guides/agent-de-code-avec-un-modele-local/ollama-ps.webp)

*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 :

```bash
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) :

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

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

```bash
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

```bash
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 :

```bash
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` :

```toml
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, Linux (script) :

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

macOS, Linux (Homebrew) :

```bash
brew install anomalyco/tap/opencode-v2
```

D'après https://opencode.ai/v2/docs (lue le 3 octobre 2026).

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 :

```json
{
  "$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](https://quelleia.com/guides/opencode-configuration/).

## 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 :

```toml
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
```

4. Gardez `active_model` au-dessus du premier tableau, sinon TOML le range dans ce tableau.
5. 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.
6. 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

- [Les modèles qui tournent en local](https://quelleia.com/classement/locaux/)
- [Quel modèle sur ma machine](https://quelleia.com/local/)
- [Classement Code des modèles de langage](https://quelleia.com/classement/code/)
- [OpenCode](https://quelleia.com/outils/opencode/)
- [Ollama](https://quelleia.com/logitheque/ollama/)
- [Le même modèle selon l'outil](https://quelleia.com/outils/harnais/)
- [Configurer OpenCode : opencode.json, modèles, agents, permissions](https://quelleia.com/guides/opencode-configuration.md) (guide, expert)
- [Harnais : pourquoi un même modèle change d'un outil à l'autre](https://quelleia.com/guides/harnais.md) (guide, amateur)
- [Installer son premier agent de code : Claude Code, Codex, Vibe](https://quelleia.com/guides/premier-agent-de-code.md) (guide, amateur)
- [MCP : brancher des outils dans Claude, ChatGPT ou un agent](https://quelleia.com/guides/mcp.md) (guide, amateur)
- [Sur mini lab AI](https://minilabai.com/guides/ollama-modeles-locaux/) : un guide du même auteur, qui va plus loin

## Sources

- https://docs.ollama.com/integrations/claude-code (lue le 17 novembre 2026)
- https://docs.ollama.com/integrations/codex (lue le 17 novembre 2026)
- https://docs.ollama.com/integrations/opencode (lue le 17 novembre 2026)
- https://opencode.ai/docs/models/ (lue le 19 novembre 2026)
- https://docs.ollama.com/integrations (lue le 17 novembre 2026)
- https://docs.ollama.com/context-length (lue le 17 novembre 2026)
- https://docs.ollama.com/faq (lue le 17 novembre 2026)
- https://docs.ollama.com/linux (lue le 17 novembre 2026)
- https://docs.ollama.com/api/openai-compatibility (lue le 17 novembre 2026)
- https://docs.mistral.ai/vibe/code/cli/offline-models (lue le 17 novembre 2026)
- https://docs.mistral.ai/vibe/code/cli/configuration (lue le 17 novembre 2026)
