Déployer un environnement de Codage Agentique local avec OpenCode et Ollama

J’ai cherché à mettre en place un environnement de développement d’IA agentique entièrement privé, gratuit et local, fonctionnant directement dans mon terminal. En associant les capacités d’OpenCode (qui peut éditer des fichiers et exécuter du code) à la puissance de calcul locale d’Ollama, j’ai obtenu exactement ce que je voulais. Au début, je me demandais si ma machine tiendrait le coup, mais la configuration s’est avérée bien plus accessible que prévu.

Voici les points clés à retenir pour réussir cette installation :

• Confidentialité absolue : Tout s’exécute en local sur votre machine, sans transfert de données vers des serveurs tiers.
• Deux approches possibles : Une méthode automatisée en une seule commande pour démarrer rapidement, ou une configuration manuelle fine via un fichier JSON pour garder un contrôle total.
• Sélection du modèle : Le choix du modèle dépend directement de vos ressources matérielles (notamment la VRAM disponible).
• Support des outils : L’activation de l’option tools est indispensable pour permettre à l’assistant d’interagir directement avec vos répertoires et vos fichiers de code.

Avant de commencer : vérifier le matériel

Pour optimiser l’environnement et choisir le bon modèle de langage, j’ai d’abord dû identifier précisément les capacités de ma machine. Si vous ne connaissez pas l’intégralité de vos spécifications techniques, voici les commandes rapides que j’utilise pour les obtenir selon le système d’exploitation.

Sur macOS :

sysctl -n hw.memsize | awk '{print $1/1073741824 " GB RAM"}'; sysctl -n machdep.cpu.brand_string

Sur Linux :

free -h && lscpu | grep "Model name" && nvidia-smi --query-gpu=name --format=csv,noheader 2>/dev/null || echo "No Nvidia GPU detected"

Sur Windows (via l’invite de commande classique ou WSL) :

wmic cpu get name && wmic path win32_VideoController get name

Le choix des modèles pour le codage local

Pour que les outils agentiques fonctionnent correctement, le modèle sous-jacent doit être particulièrement performant dans l’appel d’outils (tool calling), c’est-à-dire dans l’analyse de fichiers, l’écriture de code ou l’exécution de commandes système. D’après mes tests, deux options se détachent :

• qwen3-coder (ou qwen2.5-coder:7b) : C’est le compromis idéal pour les ordinateurs portables grand public. Sa quantification est optimisée et il offre une excellente fiabilité pour générer du code structuré.
• glm-4.7-flash : C’est l’option recommandée si vous disposez d’un processeur graphique dédié ou d’une machine avec une quantité importante de VRAM (environ 23 Go et plus), offrant ainsi des capacités de contexte étendues.

Méthode 1 : La méthode automatisée (recommandée)

C’est la solution la plus simple. Ollama intègre un lanceur qui configure, connecte et démarre automatiquement OpenCode à votre place, sans que vous n’ayez besoin de modifier manuellement le moindre fichier.

Pour ce faire, j’ai simplement validé deux prérequis : disposer d’Ollama en version v0.15 minimum et avoir installé l’interface en ligne de commande d’OpenCode.

J’ai d’abord téléchargé le modèle spécialisé dans le développement :

ollama pull qwen3-coder

Puis, j’ai lancé l’environnement complet d’une seule traite :

ollama launch opencode --model qwen3-coder

Méthode 2 : La configuration manuelle

Si vous préférez figer cette configuration ou changer manuellement de modèle depuis votre client de terminal, la modification du fichier de configuration JSON d’OpenCode est nécessaire. Pour des informations complémentaires, vous pouvez vous référer à la documentation de référence sur les intégrations d’Ollama ainsi qu’aux guides des fournisseurs OpenCode.

Dans un premier temps, on récupère le modèle :

ollama pull qwen3-coder

Il faut ensuite ouvrir ou créer le fichier de configuration global d’OpenCode nommé opencode.json. Son emplacement dépend de votre plateforme :

• Sous Linux et macOS : ~/.config/opencode/opencode.json
• Sous Windows : %USERPROFILE%\.config\opencode\opencode.json

Dans ce fichier, j’ajoute le bloc de déclaration pour le fournisseur Ollama en veillant à ce que le paramètre baseURL cible le bon port local et que l’option tools soit activée :

{
  "providers": {
    "ollama": {
      "baseURL": "http://localhost:11434/v1",
      "models": {
        "qwen3-coder": {
          "tools": true
        }
      }
    }
  },
  "defaultModel": "qama/qwen3-coder"
}

Une fois cette sauvegarde effectuée, il ne reste plus qu’à se déplacer dans le dossier de son projet informatique et à lancer l’assistant :

cd /chemin/vers/votre/projet
opencode

Configuration avancée avec opencode.json

Pour exploiter pleinement les capacités d’une carte graphique dédiée (comme une RTX 3080) et exécuter des modèles plus volumineux comme qwen3-coder:30b, on peut pousser la configuration plus loin en structurant le fichier opencode.json avec un schéma plus précis.

L’emplacement de ce fichier reste similaire, bien que sur Windows vous puissiez également utiliser l’alternative %APPDATA%\opencode\config.json.

Voici la structure de configuration complète que j’ai utilisée pour exploiter le modèle 30B avec les permissions de modification système nécessaires :

{
  "$schema": "https://opencode.ai/config.json",
  "model": "ollama/qwen3-coder:30b",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama Local",
      "options": {
        "baseURL": "http://127.0.0.1:11434/v1"
      },
      "models": {
        "qwen3-coder:30b": {
          "name": "Qwen3 Coder 30B MoE",
          "tools": true
        }
      }
    }
  },
  "tools": {
    "bash": true,
    "edit": true,
    "write": true,
    "read": true
  }
}

Pour bien comprendre les paramètres importants de cette configuration :

• “npm”: “@ai-sdk/openai-compatible” : Indique à OpenCode d’employer un protocole de communication standardisé, compatible avec l’API d’OpenAI, pour échanger avec Ollama.
• “baseURL”: “http://127.0.0.1:11434/v1” : Pointe directement vers le serveur local d’Ollama tournant en tâche de fond. Le suffixe /v1 est obligatoire ici pour assurer la compatibilité.
• “tools”: true (et le bloc “tools” détaillé à la racine) : Permet au modèle d’utiliser des fonctionnalités avancées, comme l’analyse de l’arborescence du projet, la lecture, l’écriture, la modification de fichiers, ou encore l’exécution de commandes Bash pour résoudre des dépendances en autonomie.

Démarrage de l’environnement avancé

Dès que le fichier est enregistré, l’initialisation se déroule en trois étapes rapides dans le terminal.

D’abord, le téléchargement du modèle lourd (à ne faire qu’une seule fois) :

ollama pull qwen3-coder:30b

Ensuite, le déplacement à la racine de mon projet de développement (par exemple un projet Python) :

cd /chemin/vers/votre/projet/python

Enfin, le démarrage de l’environnement de travail :

opencode