Prise en main rapide d’OpenCode : installation, configuration et utilisation de l’agent de codage IA pour le terminal

Comment installer, configurer et utiliser OpenCode

Sommaire

OpenCode est un agent de codage IA open source que vous pouvez exécuter dans le terminal (TUI + CLI), avec des interfaces bureau et IDE optionnelles. Voici le Guide de démarrage rapide OpenCode : installation, vérification, connexion à un modèle/fournisseur et exécution de flux de travail réels (CLI + API).

Note de version : OpenCode est publié rapidement. Les commandes « les plus récentes » présentées ici sont stables, mais la sortie et les valeurs par défaut peuvent évoluer. Vérifiez toujours la documentation officielle de la CLI et le journal des modifications (liés ci-dessous).

Cet article fait partie du Guide complet des outils de développement IA. Si vous maintenez également un assistant auto-hébergé tel que Nous Hermes, la Fiche de triche Hermes Agent CLI répertorie l’ensemble de commandes hermes aux côtés de ce guide de démarrage rapide OpenCode.

Qu’est-ce qu’OpenCode (et où il se situe)

OpenCode est conçu pour le codage agentique axé sur le terminal, tout en restant flexible quant au choix du fournisseur et du modèle. En pratique, c’est une couche de flux de travail qui permet de :

  • démarrer une interface utilisateur en terminal (TUI) lorsque vous exécutez opencode
  • exécuter des invites non interactives de type « coup unique » via opencode run (scripts/automatisation)
  • exposer un serveur HTTP sans interface (headless) via opencode serve (et une interface web via opencode web)
  • être contrôlé de manière programmatique via le SDK JS/TS officiel @opencode-ai/sdk

Si vous souhaitez le comparer à un autre assistant agentique open source capable d’exécuter des plans en plusieurs étapes dans un environnement isolé, consultez le Guide de démarrage rapide OpenHands CLI.

Pour l’agent axé sur le terminal d’Anthropic, qui partage la même logique « modèle local via HTTP » (Ollama ou llama.cpp, permissions, tarification), consultez l’article Installation et configuration de Claude Code pour Ollama, llama.cpp, tarification.

Pour une approche délibérément minimale de la même idée d’agent terminal — quatre outils par défaut, pas de bac à sable intégré, tout le reste via des extensions — consultez l’article Revue de l’agent de codage Pi.

opencode avec le LLM auto-hébergé qwen3.5 27b

Prérequis

Vous aurez besoin :

  • D’un émulateur de terminal moderne (important pour l’expérience TUI).
  • D’un accès à au moins un modèle/fournisseur (clés API ou authentification par abonnement, selon le fournisseur). Les options locales comme Ollama ou llama.cpp fonctionnent sans clés API lorsque vous exécutez un serveur compatible localement.

Installer OpenCode (copier-coller)

Script d’installation officiel (Linux/macOS/WSL) :

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

Options de gestionnaire de paquets (exemples officiels) :

# Installation globale Node.js
npm install -g opencode-ai

# Homebrew (recommandé par OpenCode pour les dernières versions)
brew install anomalyco/tap/opencode

# Arch Linux (stable)
sudo pacman -S opencode

# Arch Linux (dernière version depuis l'AUR)
paru -S opencode-bin

Remarques pour Windows (les conseils officiels recommandent généralement WSL pour la meilleure compatibilité). Les alternatives incluent Scoop/Chocolatey ou npm.

# chocolatey (Windows)
choco install opencode

# scoop (Windows)
scoop install opencode

Docker (utile pour un essai rapide) :

docker run -it --rm ghcr.io/anomalyco/opencode

Vérifier l’installation

opencode --version
opencode --help

Forme de la sortie attendue (varie selon la version) :

# Exemple :
# <affiche un numéro de version, ex. vX.Y.Z>
# <affiche l'aide avec les commandes/sous-commandes disponibles>

Connecter un fournisseur (deux voies pratiques)

Voie A : /connect dans la TUI (interactif)

Démarrez OpenCode :

opencode

Puis exécutez :

/connect

Suivez les étapes de l’interface utilisateur pour sélectionner un fournisseur et vous authentifier (certains flux ouvrent une connexion navigateur/appareil).

Voie B : opencode auth login en CLI (clés du fournisseur)

OpenCode prend en charge la configuration des fournisseurs via :

opencode auth login

Remarques :

  • Les identifiants sont stockés dans ~/.local/share/opencode/auth.json.
  • OpenCode peut également charger des clés à partir de variables d’environnement ou d’un fichier .env dans votre projet.

Hébergement de LLM local (Ollama, llama.cpp)

OpenCode fonctionne avec toute API compatible OpenAI. Pour le développement local, de nombreux utilisateurs exécutent Ollama et pointent OpenCode vers ce dernier. J’ai récemment eu une très bonne expérience dans la configuration et l’exécution d’OpenCode avec llama.cpp à la place — llama-server expose des points de terminaison compatibles OpenAI, vous pouvez donc utiliser des modèles GGUF avec le même flux de travail. Si vous préférez un contrôle fin de la mémoire et du temps d’exécution, ou si vous souhaitez une pile plus légère sans Python (au fait, ollama est implémenté en Go), llama.cpp mérite d’être essayé. J’ai vraiment apprécié l’opportunité de configurer les couches déchargées, la facilité d’utilisation des modèles au format GGUF et une compatibilité bien meilleure et plus rapide implémentée avec les nouveaux modèles, comme Qwen3.5. Si vous souhaitez savoir quels modèles fonctionnent réellement bien à l’intérieur d’OpenCode — dans les tâches de codage et la précision de la sortie structurée — consultez ma comparaison pratique de LLM pour OpenCode.

Démarrer correctement un projet (premier lancement recommandé)

Depository :

cd /path/to/your/repo
opencode

Puis initialisez :

/init

Cela analyse votre projet et crée un fichier AGENTS.md à la racine du projet. Il est généralement utile de commit ce fichier afin qu’OpenCode (et les coéquipiers) partagent un contexte de projet cohérent.

Flux de travail CLI principaux (exemples à copier-coller)

OpenCode prend en charge les exécutions non interactives :

opencode run "Explain how closures work in JavaScript"

Pour les motifs de flux de travail en ligne de commande — pipeline de la sortie git, cibles Makefile et CI, politiques de permissions pour les exécutions non supervisées — et les modes d’échec à anticiper, consultez le Guide pratique de la CLI OpenCode. Il s’appuie sur ce guide de démarrage rapide plutôt que de le répéter.

Flux de travail : générer du code (CLI)

Objectif : générer une petite fonction testable avec un contexte minimal.

opencode run "Write a Go function ParsePort(envVar string, defaultPort int) (int, error). It should read the env var, parse an int, validate 1-65535, and return defaultPort if empty. Include 3 table-driven tests."

Sortie attendue :

  • Une explication accompagnée de blocs de code (fonction + tests). Le code exact varie selon le modèle/fournisseur et l’invite.

Flux de travail : refactoriser un fichier en toute sécurité (CLI + agent Plan)

Objectif : confirmer que l’agent plus restrictif plan s’exécute avant de vous en reposer.

opencode run --agent plan --file ./src/auth.ts \
  "Refactor this file to reduce complexity. Output a short plan only. Do not run commands."

Sortie attendue : une section de plan, aucune modification de fichier, aucune commande exécutée.

Flux de travail : poser des questions sur le repository (CLI)

Objectif : confirmer que l’agent explore peut localiser les détails d’implémentation.

opencode run --agent explore \
  "Where is authentication validated for API requests in this repository?"

Sortie attendue : une brève carte des chemins de fichiers et une description du flux.

Ces deux-ci sont des tests de fumée en coup unique. Pour la version contrainte et de production des mêmes tâches — sortie explicite des risques/cas limites, patchs diff unifiés, invites d’exploration prenant en compte les permissions et quoi faire lorsque le modèle n’est pas conforme — consultez la section « Meilleurs cas d’usage de la CLI OpenCode » du Guide pratique de la CLI OpenCode.

Flux de travail : accélérer les exécutions CLI répétées avec un serveur persistant

Si vous écrivez des scripts ou exécutez plusieurs appels opencode run, vous pouvez démarrer un serveur sans interface une seule fois :

Terminal 1 :

opencode serve --port 4096 --hostname 127.0.0.1

Terminal 2 :

opencode run --attach http://localhost:4096 "Summarize the repo structure and main entrypoints."
opencode run --attach http://localhost:4096 "Now propose 3 high-impact refactors and why."

Sortie attendue :

  • La même que opencode run, mais généralement avec moins d’overhead de démarrage répété.

Utilisation programmatique (SDK JS/TS officiel)

OpenCode expose un serveur HTTP (OpenAPI) et fournit un client JS/TS typé.

Installation :

npm install @opencode-ai/sdk

Exemple : démarrer le serveur + le client, puis envoyer une invite

Créez scripts/opencode-sdk-demo.mjs :

import { createOpencode } from "@opencode-ai/sdk";

const opencode = await createOpencode({
  hostname: "127.0.0.1",
  port: 4096,
  config: {
    // Le format de la chaîne de modèle est fournisseur/modèle (exemple uniquement)
    // model: "anthropic/claude-3-5-sonnet-20241022",
  },
});

console.log(`Server running at: ${opencode.server.url}`);

// Vérification de base de santé/version
const health = await opencode.client.global.health();
console.log("Healthy:", health.data.healthy, "Version:", health.data.version);

// Créer une session et envoyer une invite
const session = await opencode.client.session.create({ body: { title: "SDK quickstart demo" } });

const result = await opencode.client.session.prompt({
  path: { id: session.data.id },
  body: {
    parts: [{ type: "text", text: "Generate a small README section describing this repo." }],
  },
});

console.log(result.data);

// Fermer le serveur une fois terminé
opencode.server.close();

Exécution :

node scripts/opencode-sdk-demo.mjs

Forme de la sortie attendue :

  • « Server running at … »
  • Une réponse de santé incluant une chaîne de version
  • Un objet de réponse de session (la structure exacte dépend de responseStyle et de la version du SDK)

Configuration minimale OpenCode que vous pouvez copier

OpenCode prend en charge la configuration JSON et JSONC. Voici un point de départ raisonnable pour une configuration locale au projet.

Créez opencode.jsonc à la racine de votre repository :

{
  "$schema": "https://opencode.ai/config.json",

  // Choisissez un modèle par défaut (fournisseur/modèle). Gardez cela aligné avec ce que montre `opencode models`.
  "model": "provider/model",

  // Optionnel : un « petit modèle » moins coûteux pour les tâches légères (titres, etc.)
  "small_model": "provider/small-model",

  // Optionnel : valeurs par défaut du serveur OpenCode (utilisées par serve/web)
  "server": {
    "port": 4096,
    "hostname": "127.0.0.1"
  },

  // Sécurité optionnelle : exiger une confirmation avant les modifications/commandes
  "permission": {
    "edit": "ask",
    "bash": "ask"
  }
}

Pour une politique de permissions plus complète destinée aux tâches opencode run non supervisées, consultez le Guide pratique de la CLI OpenCode.

La mémoire de projet entre les sessions est une installation séparée. Hindsight Memory pour OpenCode, Cursor et autres agents de codage ajoute le plugin au fichier ~/.config/opencode/opencode.json au niveau de l’utilisateur, un fichier différent du opencode.jsonc du projet ci-dessus.

Brève fiche de triche (référence rapide)

Commandes que vous utiliserez quotidiennement

opencode                       # démarrer la TUI
opencode run "..."             # exécution non interactive (automatisation)
opencode run --file path "..." # joindre des fichiers à l'invite
opencode models --refresh      # actualiser la liste des modèles
opencode auth login            # configurer les identifiants du fournisseur
opencode serve                 # serveur HTTP sans interface (OpenAPI)
opencode web                   # serveur sans interface + interface web
opencode session list          # lister les sessions
opencode stats                 # statistiques de jetons/coûts

Commandes TUI à retenir

/connect   # connecter un fournisseur
/init      # analyser le repository, générer AGENTS.md
/share     # partager une session (si activée)
/undo      # annuler une modification
/redo      # rétablir une modification
/help      # aide/raccourcis

Concept de « touche leader » par défaut (TUI)

OpenCode utilise une touche « leader » configurable (généralement ctrl+x) pour éviter les conflits terminaux. Beaucoup de raccourcis sont « Leader + touche ».

Tableau de triche OpenCode imprimable sur une page

Cette version est intentionnellement dense et « adaptée à l’impression ». (Vous pouvez la coller plus tard dans une page dédiée /ai-devtools/opencode/cheatsheet/.)

Tâche Commande / raccourci Remarques
Démarrer la TUI opencode Le comportement par défaut est de lancer l’interface utilisateur en terminal
Exécuter une invite en coup unique opencode run "..." Mode non interactif pour le script/l’automatisation
Joindre un/fichiers à l’invite opencode run --file path/to/file "..." Utilisez plusieurs drapeaux --file pour plusieurs fichiers
Choisir un modèle pour une exécution opencode run --model provider/model "..." Les chaînes de modèle sont fournisseur/modèle
Choisir un agent opencode run --agent plan "..." Plan est conçu pour un travail plus sûr « sans modifications » (restrictions de permission)
Lister les modèles opencode models [provider] Utilisez --refresh pour mettre à jour la liste en cache
Configurer les identifiants du fournisseur opencode auth login Stocke les identifiants dans ~/.local/share/opencode/auth.json
Lister les fournisseurs authentifiés opencode auth list / opencode auth ls Confirme ce que voit OpenCode
Démarrer un serveur sans interface opencode serve --port 4096 --hostname 127.0.0.1 Spécification OpenAPI sur http://host:port/doc
Joindre des exécutions au serveur opencode run --attach http://localhost:4096 "..." Utile pour éviter les démarrages à froid répétés
Activer l’authentification de base OPENCODE_SERVER_PASSWORD=... opencode serve Le nom d’utilisateur est opencode par défaut sauf si modifié
Mode interface web opencode web Démarre le serveur + ouvre le navigateur
Exporter une session opencode export [sessionID] Utile pour archiver ou partager le contexte
Importer une session opencode import session.json Peut également importer depuis une URL de partage
Voir les drapeaux globaux de la CLI opencode --help / opencode --version --print-logs + --log-level pour le débogage
Concept de touche leader TUI touche leader par défaut souvent ctrl+x Personnalisable dans tui.json

Oh My Opencode — poussez OpenCode plus loin avec l’orchestration multi-agent

Une fois OpenCode en marche, l’étape suivante naturelle est Oh My Opencode — un plugin de la communauté qui enveloppe OpenCode dans un harnais multi-agent. L’idée principale : tapez ultrawork (ou ulw) dans une session et un orchestrateur (Sisyphus) prend le relais, en déléguant des sous-tâches à des agents spécialisés qui s’exécutent en parallèle, chacun sur la famille de modèles pour laquelle ses invites sont optimisées.

Trois articles en couvrent la profondeur :

OpenCode était l’un des premiers outils affectés par la politique d’Anthropic consistant à bloquer l’accès d’abonnements Claude par des tiers — une mesure prise en janvier 2026, un mois avant que la même restriction ne touche OpenClaw. La Chronologie de la montée et de la chute d’OpenClaw documente ces deux événements et le motif plus large qu’ils représentent pour les outils d’agents construits sur le calcul par abonnement.

Sources (officielles en premier)

Officiel :

Référence d’intégration fiable :

Comparaisons/tutoriels réputés :

S'abonner

Recevez de nouveaux articles sur les systèmes, l'infrastructure et l'ingénierie IA.