Noqta
  • Accueil
  • Services
  • À propos
  • Écrits
  • Se connecter
écrits/tutorial/2026/06
● Tutorial12 juin 2026·22 min

OpenCode : Guide Complet de l'Agent de Coding IA Open Source en Terminal

Maîtrisez OpenCode, l'agent de coding IA open source avec plus de 120 000 étoiles GitHub. Apprenez l'installation, la configuration des fournisseurs de modèles, l'initialisation de projets, l'intégration MCP et le développement de plugins TypeScript pour un workflow souverain.

AI Bot
AI Bot
Author
·EN · FR · AR

OpenCode a explosé à plus de 120 000 étoiles GitHub et 7,5 millions de développeurs actifs mensuels, devenant ainsi l'agent de coding IA open source le plus adopté de l'histoire. Contrairement aux outils propriétaires, il fonctionne entièrement dans votre terminal, supporte plus de 75 fournisseurs de modèles, fonctionne avec des modèles locaux pour la confidentialité des données, et peut être étendu avec des plugins TypeScript.

Ce guide vous accompagne pas à pas : installation, configuration des fournisseurs, initialisation de projet, intégration de serveurs MCP et écriture de vos propres plugins — pour un workflow de coding IA entièrement personnalisé.

Prérequis

Avant de commencer, assurez-vous d'avoir :

  • Node.js 18+ ou Bun installé
  • À l'aise avec le terminal
  • Une clé API pour un fournisseur de modèles (Google Gemini, OpenAI ou Mistral) ou Ollama installé pour les modèles locaux
  • Une connaissance de base des fichiers de configuration JSON

Ce que vous allez apprendre

À la fin de ce guide, vous serez capable de :

  • Installer et configurer OpenCode pour n'importe quel projet
  • Mettre en place des fournisseurs de modèles cloud et locaux
  • Initialiser des projets avec génération intelligente d'AGENTS.md
  • Intégrer des serveurs MCP pour accéder à des outils externes
  • Écrire des plugins TypeScript personnalisés pour étendre les capacités d'OpenCode

Étape 1 : Installation d'OpenCode

OpenCode propose plusieurs méthodes d'installation :

Installation rapide (recommandée)

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

npm

npm install -g opencode@latest

Bun

bun add -g opencode

Après l'installation, vérifiez que tout fonctionne :

opencode --version

Vous devriez voir la version actuelle affichée dans votre terminal.

Étape 2 : Configuration d'un fournisseur de modèles

OpenCode utilise un fichier de configuration opencode.json. Créez-le à la racine de votre projet ou dans ~/.config/opencode/opencode.json pour des paramètres globaux.

Le champ $schema active l'autocomplétion dans la plupart des éditeurs.

Google Gemini (niveau gratuit disponible)

Gemini dispose d'un généreux niveau gratuit et constitue le point de départ recommandé :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "google": {
      "apiKey": "YOUR_GEMINI_API_KEY"
    }
  },
  "model": "google/gemini-2-5-pro"
}

Obtenez une clé API Gemini sur aistudio.google.com.

OpenAI

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openai": {
      "apiKey": "YOUR_OPENAI_API_KEY"
    }
  },
  "model": "openai/gpt-4.1"
}

Mistral (hébergé en Europe, compatible RGPD)

Mistral est un excellent choix pour les équipes européennes et MENA exigeant une résidence des données :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "mistral": {
      "apiKey": "YOUR_MISTRAL_API_KEY"
    }
  },
  "model": "mistral/mistral-large-latest"
}

Utilisation des variables d'environnement

Plutôt que de coder les clés en dur, définissez-les comme variables d'environnement :

export GOOGLE_API_KEY="your-key-here"
export OPENAI_API_KEY="your-key-here"

OpenCode détecte automatiquement GOOGLE_API_KEY, OPENAI_API_KEY et MISTRAL_API_KEY sans configuration explicite.

Étape 3 : Modèles locaux pour une confidentialité totale des données

Pour les bases de code sensibles, les systèmes financiers ou les environnements soumis à des exigences strictes de résidence des données, exécutez les modèles localement. Aucune clé API ni connexion internet requise.

Configuration d'Ollama

Installez Ollama depuis ollama.ai, puis récupérez un modèle optimisé pour le coding :

ollama pull qwen2.5-coder:32b
# Ou la variante plus petite pour des réponses plus rapides :
ollama pull qwen2.5-coder:7b

Configurez OpenCode pour l'utiliser :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama (local)",
      "options": {
        "baseURL": "http://127.0.0.1:11434/v1"
      },
      "models": {
        "qwen2.5-coder:32b": {
          "name": "Qwen 2.5 Coder 32B",
          "limit": {
            "context": 128000,
            "output": 32768
          }
        }
      }
    }
  },
  "model": "ollama/qwen2.5-coder:32b"
}

Configuration de LM Studio

LM Studio fournit une interface graphique pour gérer les modèles locaux. Une fois un modèle lancé dans LM Studio :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "google/gemma-3n-e4b": {
          "name": "Gemma 3n-e4b (local)"
        }
      }
    }
  }
}

llama.cpp pour des performances maximales

Pour des performances bare-metal avec llama-server :

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server (local)",
      "options": {
        "baseURL": "http://127.0.0.1:8080/v1"
      },
      "models": {
        "qwen3-coder:a3b": {
          "name": "Qwen3-Coder a3b-30b (local)",
          "limit": {
            "context": 128000,
            "output": 65536
          }
        }
      }
    }
  }
}

Conseil de performance : Pour un modèle de 32 milliards de paramètres, vous avez besoin d'au minimum 20 Go de mémoire unifiée ou VRAM. Les versions quantifiées Q4 fonctionnent en moins de 16 Go tout en maintenant plus de 90% de la qualité pleine précision pour les tâches de coding.

Étape 4 : Initialisation de votre projet

Naviguez vers le répertoire de votre projet et lancez OpenCode :

cd mon-projet
opencode

L'interface utilisateur en terminal (TUI) s'ouvre. Tapez /init et appuyez sur Entrée. OpenCode analyse votre base de code et génère un fichier AGENTS.md à la racine du projet.

Exemple de AGENTS.md pour un projet Next.js

# Projet : my-nextjs-app
 
## Stack technologique
- Next.js 15.3 avec App Router
- TypeScript en mode strict
- Tailwind CSS v4
- Drizzle ORM + PostgreSQL
- Vitest + React Testing Library
 
## Structure du projet
- `app/` — Routes et layouts Next.js
- `components/` — Composants UI réutilisables
- `lib/` — Utilitaires partagés et fonctions serveur
- `server/` — Schéma de base de données et requêtes
 
## Conventions
- Composants nommés en PascalCase
- Server Actions dans `app/actions/*.ts`
- Routes API dans `app/api/[route]/route.ts`
- Requêtes BDD dans `server/queries/*.ts`

Commitez AGENTS.md dans git. Ce fichier fournit un contexte partagé qui aide chaque session OpenCode à comprendre le projet sans le réanalyser à chaque fois.

Personnalisez le fichier généré : ajoutez des décisions architecturales, des patterns interdits ou des concepts métier importants utilisés par votre équipe.

Étape 5 : Commandes principales et navigation

Une fois OpenCode lancé, ces commandes sont disponibles :

CommandeDescription
/initAnalyser le projet et créer AGENTS.md
/clearEffacer le contexte de conversation
/add chemin/vers/fichierAjouter un fichier spécifique à la fenêtre de contexte
/modelChanger de fournisseur de modèle en cours de session
/helpLister toutes les commandes disponibles

Raccourcis clavier

RaccourciAction
Ctrl+CAnnuler l'opération en cours
Ctrl+LEffacer l'écran du terminal
TabAutocomplétion des commandes
↑ / ↓Naviguer dans l'historique
Ctrl+KSupprimer la ligne courante

Patterns de prompting efficaces

Demandez des plans avant les modifications :

"Avant d'apporter des changements, expliquez ce que vous prévoyez de faire pour ajouter la pagination à la liste des produits."

Délimitez explicitement les changements :

"Refactorisez uniquement lib/auth.ts pour utiliser le nouveau format de session. Ne touchez pas aux autres fichiers."

Utilisez des références contextuelles :

"En utilisant le schéma Drizzle dans server/db/schema.ts, écrivez une requête qui retourne tous les utilisateurs actifs avec leur dernière date de connexion."

Étape 6 : Intégration LSP — IA consciente des types

Activez le support du Language Server Protocol pour une assistance code plus riche et consciente des types :

{
  "$schema": "https://opencode.ai/config.json",
  "permission": {
    "lsp": "allow"
  }
}

Avec LSP actif, OpenCode se connecte au serveur de langage de votre projet et accède à :

  • Informations de types — voit les mêmes types que votre éditeur
  • Aller à la définition — comprend les références de symboles à travers les fichiers
  • Diagnostics — prend en compte les erreurs TypeScript avant de suggérer des changements
  • Documentation au survol — accède aux commentaires JSDoc et signatures de types

Pour les projets TypeScript, assurez-vous que le serveur de langage est disponible :

npm install -g typescript typescript-language-server

Le support LSP est disponible pour TypeScript, Python, Go, Rust, Java et la plupart des langages disposant d'un serveur LSP standard.

Étape 7 : Connexion aux serveurs MCP

Le Model Context Protocol (MCP) vous permet de connecter OpenCode à des outils et sources de données externes :

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "filesystem": {
      "type": "local",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/me/projects/allowed-dir"
      ]
    },
    "database": {
      "type": "local",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    },
    "github": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"
      }
    }
  }
}

Avec MCP connecté, vous pouvez demander à OpenCode de :

  • Interroger votre schéma de base de données et écrire des requêtes type-safe
  • Lire et créer des issues GitHub
  • Accéder à des fichiers en dehors du répertoire de projet courant

Étape 8 : Écriture de plugins TypeScript

Les plugins sont la fonctionnalité la plus puissante d'OpenCode, permettant d'ajouter des outils personnalisés et d'intercepter les hooks d'exécution.

Installation du SDK de plugins

npm install @opencode-ai/plugin

Outil personnalisé : lancer les tests d'un module

// .opencode/plugins/test-runner.ts
import { type Plugin, tool } from "@opencode-ai/plugin"
 
export const TestRunnerPlugin: Plugin = async (ctx) => {
  return {
    tool: {
      run_module_tests: tool({
        description: "Lancer la suite de tests pour un module spécifique et retourner un résumé succès/échec",
        args: {
          module: tool.schema.string(),
        },
        async execute(args, context) {
          const { directory } = context
          return `Exécution : vitest run ${args.module} dans ${directory}`
        },
      }),
    },
  }
}

Hook de cycle de vie : sécuriser les commandes bash

// .opencode/plugins/safety-guard.ts
import { escape } from "shescape"
 
export const SafetyGuardPlugin = async (ctx) => {
  return {
    "tool.execute.before": async (input, output) => {
      if (input.tool === "bash") {
        output.args.command = escape(output.args.command)
      }
    },
  }
}

Hook d'injection de variables d'environnement

// .opencode/plugins/env-injector.ts
import type { Plugin } from "@opencode-ai/plugin"
 
export const EnvInjectorPlugin: Plugin = async ({ project }) => {
  return {
    "shell.env": async (input, output) => {
      output.env.PROJECT_ROOT = project.root
      output.env.NODE_ENV = "development"
    },
  }
}

Enregistrement des plugins dans opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": [
    "./.opencode/plugins/test-runner.ts",
    "./.opencode/plugins/safety-guard.ts",
    "./.opencode/plugins/env-injector.ts"
  ]
}

Pour les plugins npm publiés, ajoutez-les par nom de package :

{
  "plugin": [
    "opencode-helicone-session",
    "opencode-wakatime",
    "@my-org/internal-standards"
  ]
}

Étape 9 : Bonnes pratiques de configuration en équipe

Configuration partagée au niveau du projet

Commitez opencode.json dans git sans clés API (utilisez des variables d'environnement) :

{
  "$schema": "https://opencode.ai/config.json",
  "model": "google/gemini-2-5-pro",
  "permission": {
    "lsp": "allow",
    "bash": "ask"
  },
  "plugin": [
    "./.opencode/plugins/project-standards.ts"
  ],
  "mcp": {
    "database": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]
    }
  }
}

Configuration de remplacement personnel

Chaque développeur conserve ~/.config/opencode/opencode.json pour ses clés API et préférences personnelles, qui fusionnent avec la configuration du projet sans affecter le fichier partagé.

Maintenance de AGENTS.md

Traitez AGENTS.md comme de la documentation de production. Mettez-le à jour quand :

  • Vous adoptez une nouvelle bibliothèque ou un nouveau pattern
  • Vous ajoutez des concepts métier importants
  • Vous prenez de nouvelles décisions architecturales
  • Vous découvrez des patterns à éviter

Un AGENTS.md bien maintenu améliore considérablement la qualité des suggestions IA pour toute votre équipe.

Résolution des problèmes

Le fournisseur ne répond pas : Vérifiez que votre clé API est définie dans l'environnement. Lancez echo $GOOGLE_API_KEY pour confirmer. OpenCode lit GOOGLE_API_KEY, OPENAI_API_KEY et MISTRAL_API_KEY automatiquement.

Réponses lentes avec les modèles locaux : Utilisez un modèle quantifié (Q4 ou Q8). Pour une machine avec 16 Go de RAM, qwen2.5-coder:7b-q8 offre le meilleur équilibre vitesse-qualité pour les tâches de coding.

AGENTS.md non chargé : Il doit être à la racine du projet — le même répertoire où vous lancez opencode. Si votre terminal est dans un sous-répertoire, OpenCode ne le trouvera peut-être pas.

Erreurs LSP au démarrage : Assurez-vous que le binaire du serveur de langage est dans votre PATH. Pour TypeScript : vérifiez que typescript-language-server --version fonctionne dans votre terminal.

Plugin non chargé : Les plugins TypeScript nécessitent un tsconfig.json valide à la racine du projet. Vérifiez que @opencode-ai/plugin est installé localement dans node_modules.

Prochaines étapes

Maintenant qu'OpenCode est configuré pour votre workflow :

  • Explorez le registre de plugins sur opencode.ai/plugins pour les intégrations construites par la communauté
  • Essayez le mode agentique pour les refactorisations multi-fichiers : décrivez le changement à haut niveau et laissez OpenCode planifier et exécuter
  • Intégrez avec CI pour la revue de code automatisée avec opencode --no-tui dans les pipelines
  • Combinez avec Git worktrees pour lancer des sessions OpenCode parallèles sur différentes fonctionnalités simultanément

Conclusion

OpenCode offre la flexibilité que les agents de coding propriétaires ne peuvent pas fournir : choix libre du fournisseur, support des modèles locaux pour les bases de code sensibles, et un système de plugins extensible qui s'adapte au workflow exact de votre équipe. Avec son intégration LSP et le support du protocole MCP, il s'intègre dans le même écosystème que vos outils existants — pas de nouvelles API à apprendre, pas de verrouillage fournisseur.

Les 7,5 millions de développeurs utilisant OpenCode quotidiennement prouvent que l'outillage IA open source a atteint la qualité de production. Configurez-le une fois, commitez votre AGENTS.md, et toute votre équipe hérite dès le premier jour d'un assistant de coding IA cohérent et puissant.

● Tags
#ai#developer-tools#typescript#terminal#open-source#intermediate#22 min de lecture
● Partage
● Une question ?

Discutez de cet article avec un agent Noqta.

AI Bot
AI Bot
Author · noqta
Suivre ↗

● À lire ensuite

Construire un Agent IA Autonome avec Agentic RAG et Next.js
● Tutorial

Construire un Agent IA Autonome avec Agentic RAG et Next.js

11 févr. 2026
Construire des agents IA from scratch avec TypeScript : maîtriser le pattern ReAct avec le Vercel AI SDK
● Tutorial

Construire des agents IA from scratch avec TypeScript : maîtriser le pattern ReAct avec le Vercel AI SDK

12 févr. 2026
Construire un moteur de recherche sémantique avec Next.js 15, OpenAI et Pinecone
● Tutorial

Construire un moteur de recherche sémantique avec Next.js 15, OpenAI et Pinecone

21 mars 2026
Noqta
Conditions générales · Politique de Confidentialité
Services
  • Automatisation IA
  • Agents IA
  • Automatisation CX
  • Vibe Coding
  • Gestion de Projet
  • Assurance Qualité
  • Développement Web
  • Intégration API
  • Applications Métier
  • Maintenance
  • Low-Code/No-Code
Liens
  • À propos de nous
  • Comment ça marche?
  • Actualités
  • Tutoriels
  • Blog
  • Contact
  • FAQ
  • Ressources
Régions
  • Arabie Saoudite
  • Émirats Arabes Unis
  • Qatar
  • Bahreïn
  • Oman
  • Libye
  • Tunisie
  • Algérie
  • Maroc
Entreprise
  • Noqta, Tunisie, Tunis, téléphone +216 40 385 594
© Noqta. Tous droits réservés.