OpenCode + Ollama : un agent de code dans votre terminal

#Pourquoi OpenCode en local

OpenCode est un TUI (interface terminal) open source, agnostique côté modèle : il parle à n'importe quel fournisseur exposant une API compatible OpenAI. C'est précisément ce qu'expose Ollama, ce qui rend le couple naturel. Contrairement à une extension d'IDE, OpenCode ne dépend d'aucun éditeur : il s'ouvre dans le même terminal que git, npm ou vos tests, et raisonne sur l'ensemble du dépôt.

L'intérêt du 100 % local n'est pas idéologique. Un agent de code voit tout : arborescence, secrets en clair dans un .env oublié, logique métier. En restant sur Ollama, ce contexte ne quitte jamais la machine — pas de facturation au token, pas de fuite, pas de dépendance réseau. Le prix à payer : un modèle local de 7 à 32B n'a pas le niveau d'un modèle frontier cloud. Le reste du guide sert à tirer le meilleur de ce compromis.

#Prérequis

Ollama installé

Le daemon doit tourner et écouter sur http://localhost:11434 (valeur par défaut). Vérifiez avec « ollama list ».

Un GPU confortable

L'agentique consomme beaucoup de contexte. Comptez 16 Go de VRAM minimum pour un modèle de code utile (RTX 4080, 4090, ou Mac Apple Silicon 24-48 Go en mémoire unifiée).

Un terminal moderne

OpenCode est un TUI : un terminal supportant les couleurs 256 et l'UTF-8 (Windows Terminal, iTerm2, Kitty, Alacritty…).

Un projet git

Recommandé mais pas obligatoire. OpenCode s'appuie sur git pour suivre et annuler ses modifications.

#Installer OpenCode

OpenCode se distribue via un script d'installation universel, ou par les gestionnaires de paquets habituels. Choisissez la méthode adaptée à votre système.

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

npm install -g opencode-ai

brew install sst/tap/opencode

Une fois installé, vérifiez la version et lancez OpenCode depuis la racine de votre projet. Au premier démarrage, il crée un dossier de configuration et ouvre son interface terminal.

opencode --version
cd ~/mon-projet
opencode

#Configurer l'endpoint Ollama

OpenCode ne connaît pas Ollama par défaut : il faut déclarer un fournisseur pointant sur l'endpoint OpenAI-compatible local. Cet endpoint se trouve à http://localhost:11434/v1. La configuration se fait dans un fichier JSON, soit global (~/.config/opencode/opencode.json), soit par projet (opencode.json à la racine).

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen3-coder:30b": { "name": "Qwen3-Coder 30B" },
        "devstral:24b": { "name": "Devstral Small 2" }
      }
    }
  }
}

Chaque clé sous « models » doit correspondre exactement au tag du modèle tel qu'il apparaît dans « ollama list ». Une fois le fichier enregistré, relancez OpenCode : le sélecteur de modèle (raccourci affiché en bas de l'interface) proposera désormais vos modèles Ollama sous le fournisseur « Ollama (local) ».

# Option 1 : variable d'environnement (relancer le daemon)
export OLLAMA_CONTEXT_LENGTH=32768
ollama serve

# Option 2 : Modelfile dédié
printf 'FROM qwen3-coder:30b\nPARAMETER num_ctx 32768\n' > Modelfile
ollama create qwen3-coder-32k -f Modelfile

#Quel modèle local choisir pour l'agentique

Tous les modèles ne se valent pas pour l'agentique. Un agent doit appeler des outils (lire, écrire, exécuter) de façon fiable et produire des diffs cohérents. Les modèles entraînés pour le code et le tool-calling s'en sortent nettement mieux que les généralistes. Repères VRAM en Q4_K_M : 7B≈5 Go, 14B≈9 Go, 32B≈19 Go.

Qwen3-Coder 30B (24 Go)

Le meilleur rapport qualité/local pour l'agentique en 2026. Excellent tool-calling, diffs propres. Tient en Q4 sur une RTX 4090 ou un Mac 32 Go.

Devstral Small 2 (16 Go)

Modèle de Mistral pensé pour les agents de code. Bonne option si vous plafonnez à 16 Go de VRAM (RTX 4080).

Qwen3-Coder 7B (8 Go)

Le minimum viable. Utilisable pour des tâches simples et ciblées, mais décroche vite sur les refactors multi-fichiers.

À éviter

Les petits modèles généralistes sans entraînement tool-use : ils hallucinent les appels d'outils et cassent le workflow agent.

#Workflow agent réel sur un petit projet

Prenons un cas concret : ajouter une route à une petite API Express et couvrir le nouveau endpoint avec un test. Voici comment se déroule une session OpenCode de bout en bout.

1. 01
   Ouvrir le projet

   Depuis la racine du dépôt, lancez « opencode ». L'agent indexe l'arborescence et attend une instruction. Vérifiez en bas que le modèle sélectionné est bien votre modèle Ollama.
2. 02
   Décrire la tâche en langage naturel

   Tapez votre demande : « Ajoute une route GET /health qui renvoie { status: 'ok' } dans src/server.js, puis écris un test pour cette route dans test/health.test.js. » L'agent commence par lire les fichiers concernés.
3. 03
   Lire et planifier

   OpenCode ouvre src/server.js pour comprendre le style existant (framework, conventions, format des routes) avant de proposer un plan. C'est ce contexte de projet qui fait la différence avec un simple chat.
4. 04
   Valider les modifications

   L'agent présente un diff pour chaque fichier. Vous approuvez, refusez ou demandez un ajustement. Rien n'est écrit sur le disque sans votre accord — l'approbation reste sous votre contrôle.
5. 05
   Exécuter et itérer

   OpenCode peut lancer « npm test » lui-même, lire la sortie et corriger si un test échoue. Cette boucle exécuter → observer → corriger est le cœur de l'agentique.
6. 06
   Commiter

   Une fois satisfait, demandez à l'agent de créer un commit, ou faites-le à la main. Comme tout passe par git, un « git diff » ou un « git reset » annule proprement une session ratée.

Sur un modèle local 30B, chaque étape est plus lente qu'avec un modèle cloud, et il faut parfois reformuler une instruction ambiguë. Mais le résultat est réel : du code écrit, testé et commité sans qu'une ligne ne quitte votre machine.

#OpenCode vs Cline vs Aider

OpenCode, Cline et Aider visent le même but — un agent de code sur LLM local — mais avec des philosophies différentes. Le bon choix dépend de votre environnement de travail.

OpenCode

TUI autonome dans le terminal, indépendant de tout éditeur. Idéal si vous vivez dans le terminal (tmux, ssh, serveurs distants). Multi-fournisseurs, config JSON claire.

Cline

Extension VS Code : chat + mode agent directement dans l'éditeur, avec visualisation des diffs dans l'UI. Le meilleur choix si votre flux tourne autour de VS Code.

Aider

CLI historique, très intégré à git (commits automatiques, repo-map). Excellent pour les modifications ciblées et le travail par petits pas, avec un contrôle fin des fichiers ajoutés au contexte.

En résumé : Cline si vous êtes dans l'IDE, Aider si vous voulez un contrôle git chirurgical et une longue maturité, OpenCode si vous voulez un agent terminal moderne et découplé de l'éditeur. Les trois se branchent sur le même Ollama — rien ne vous empêche de les essayer tous et de garder celui qui colle à vos habitudes.

#Dépannage

Le modèle n'apparaît pas

Le tag dans opencode.json ne correspond pas à « ollama list ». Copiez-collez le nom exact, tag inclus (ex. qwen3-coder:30b).

L'agent oublie le contexte

num_ctx trop bas côté Ollama. Étendez la fenêtre (voir plus haut) : 32768 est un bon point de départ pour l'agentique.

Connexion refusée

Le daemon Ollama ne tourne pas, ou écoute sur une autre adresse. Vérifiez « ollama list » et que baseURL pointe bien sur http://localhost:11434/v1.

Les appels d'outils échouent

Le modèle ne gère pas bien le tool-calling. Passez à un modèle de code entraîné pour l'agentique (Qwen3-Coder, Devstral).

Réponses très lentes

Le modèle déborde de la VRAM et s'exécute partiellement sur CPU. Prenez une quantization plus légère (Q4_K_M) ou un modèle plus petit.

#Pour aller plus loin

Ces guides complètent naturellement votre setup d'agent de code local :

Cline + Ollama : un agent de code dans VS Code

La variante IDE d'OpenCode : mêmes principes, mais intégrée à VS Code avec diffs visuels et provider Ollama.

Aider + Ollama : coder dans le terminal en 100 % local

L'autre agent terminal, très centré git. Utile pour comparer les deux approches sur votre propre projet.

Choisir sa quantification (Q4, Q5, Q8, FP16)

Pour faire tenir le plus gros modèle de code possible dans votre VRAM sans sacrifier la qualité des diffs.