OpenCode Quickstart: installeren, configureren en gebruiken van de Terminal AI Coding Agent

Hoe u OpenCode installeert, configureert en gebruikt

Inhoud

OpenCode is een open-source AI-coding agent die je in de terminal kunt uitvoeren (TUI + CLI) met optionele desktop- en IDE-interfaces. Dit is de OpenCode Quickstart: installeren, verifiëren, een model/aanbieder verbinden en werkelijke workflows uitvoeren (CLI + API).

Versie-opmerking: OpenCode wordt snel geleverd. De hieronder getoonde “nieuwste” commando’s zijn stabiel, maar de uitvoer en standaardinstellingen kunnen veranderen—controleer altijd de officiële CLI-documentatie en het changelog (hieronder gelinkt).

Dit artikel is onderdeel van AI Developer Tools: De Complete Gids voor AI-Gedreven Ontwikkeling.

Wat OpenCode is (en waar het past)

OpenCode is ontworpen voor terminal-first, agentische coding, terwijl het flexibel blijft qua aanbieder/model. In de praktijk is het een workflow-laag die het volgende kan doen:

  • een terminal-UI starten als je opencode uitvoert
  • niet-interactieve “one-shot”-prompts uitvoeren via opencode run (scripts/automatisering)
  • een headless HTTP-server blootstellen via opencode serve (en een web-UI via opencode web)
  • programmatisch worden bestuurd via de officiële JS/TS SDK @opencode-ai/sdk

Als je het wilt vergelijken met een andere open-source agentische assistent die meervoudige stappen in een sandbox-omgeving kan uitvoeren, zie OpenHands Coding Assistant QuickStart.

Voor Anthropic’s terminal-first agent met hetzelfde verhaal van “lokaal model via HTTP” (Ollama of llama.cpp, machtigingen, prijzen), zie Claude Code installatie en configuratie voor Ollama, llama.cpp, prijzen.

opencode met self-hosted qwen3.5 27b LLM

Vereisten

Je hebt het volgende nodig:

  • Een moderne terminal-emulator (belangrijk voor de TUI-ervaring).
  • Toegang tot ten minste één model/aanbieder (API-sleutels of abonnementsauthenticatie, afhankelijk van de aanbieder). Lokale opties zoals Ollama of llama.cpp werken zonder API-sleutels als je een compatibele server lokaal uitvoert.

OpenCode installeren (kopieer-plak)

Officiële installatiescript (Linux/macOS/WSL):

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

Opties voor pakketbeheer (officiële voorbeelden):

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

# Homebrew (aanbevolen door OpenCode voor de meest actuele releases)
brew install anomalyco/tap/opencode

# Arch Linux (stabiel)
sudo pacman -S opencode

# Arch Linux (nieuwste uit AUR)
paru -S opencode-bin

Windows-opmerkingen (officiële richtlijnen adviseren doorgaans WSL voor de beste compatibiliteit). Alternatieven zijn Scoop/Chocolatey of npm.

# chocoloatey (Windows)
choco install opencode

# scoop (Windows)
scoop install opencode

Docker (handig voor een snelle test):

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

Installatie verifiëren

opencode --version
opencode --help

Verwachte uitvoer (varieert per versie):

# Voorbeeld:
# <print een versienummer, bijv. vX.Y.Z>
# <print hulp met beschikbare commando's/subcommando's>

Een aanbieder verbinden (twee praktische paden)

Pad A: TUI /connect (interactief)

Start OpenCode:

opencode

Vervolgens uitvoeren:

/connect

Volg de stappen in de UI om een aanbieder te selecteren en te authenticeren (sommige flows openen een browser/apparaat-login).

Pad B: CLI opencode auth login (aanbiedersleutels)

OpenCode ondersteunt het configureren van aanbieders via:

opencode auth login

Opmerkingen:

  • Aanmeldgegevens worden opgeslagen in ~/.local/share/opencode/auth.json.
  • OpenCode kan ook sleutels laden uit omgevingsvariabelen of een .env-bestand in je project.

Lokale LLM-hosting (Ollama, llama.cpp)

OpenCode werkt met elke OpenAI-compatibele API. Voor lokale ontwikkeling voeren veel gebruikers Ollama uit en wijzen OpenCode daarop. Ik heb onlangs zeer goede ervaringen gehad met het configureren en uitvoeren van OpenCode met llama.cpp in plaats daarvan—llama-server exposeert OpenAI-compatibele endpoints, zodat je GGUF-modellen kunt gebruiken met dezelfde workflow. Als je fijnkorrelige controle wilt over geheugen en runtime, of een lichtere stack zonder Python wilt (overigens is ollama geïmplementeerd in Go), is llama.cpp de moeite waard om te proberen. Ik heb echt genoten van de mogelijkheid om offgeladen lagen te configureren, het gebruiksgemak van de modellen in GGUF-formaat en de veel betere/snelder geïmplementeerde compatibiliteit met nieuwe modellen, zoals Qwen3.5. Als je wilt weten welke modellen daadwerkelijk goed presteren binnen OpenCode — over coding-taken en structuur-uitvoer nauwkeurigheid heen — zie mijn praktische LLM-vergelijking voor OpenCode.

Start een project correct (aanbevolen eerste run)

Vanaf je repo:

cd /path/to/your/repo
opencode

Vervolgens initialiseren:

/init

Dit analyseert je project en maakt een AGENTS.md-bestand in de projectroot. Het is doorgaans de moeite waard om dit bestand te committen zodat OpenCode (en teamleden) consistente projectcontext delen.

Kern CLI-workflows (kopieer-plak voorbeelden)

OpenCode ondersteunt niet-interactieve runs:

opencode run "Leg uit hoe closures werken in JavaScript"

Workflow: code genereren (CLI)

Doel: een kleine, testbare functie genereren met minimale context.

opencode run "Schrijf een Go-functie ParsePort(envVar string, defaultPort int) (int, error). Het zou de omgevingsvariabele moeten lezen, een int parsen, valideren op 1-65535 en defaultPort teruggeven als leeg. Voeg 3 table-driven tests toe."

Verwachte uitvoer:

  • Een uitleg plus codeblokken (functie + tests). Exacte code varieert per model/aanbieder en prompt.

Workflow: een bestand veilig refactoren (CLI + Plan agent)

Doel: refactoren zonder onbedoelde edits door een restrictievere agent te gebruiken.

opencode run --agent plan --file ./src/auth.ts \
  "Refactor dit bestand om de complexiteit te verminderen. Uitvoer: (1) een kort plan, (2) een unified diff patch, (3) risico's/edge-cases om te testen. Voer geen commando's uit."

Verwachte uitvoer:

  • Een plan-sectie + een diff --git ... patch-blok + een test-checklist.
  • Inhoud varieert. Als het geen diff produceert, prompt opnieuw: “Geef alleen een unified diff terug” of “Gebruik diff --git formaat.”

Workflow: repo-vragen stellen (CLI)

Doel: implementatiedetails snel lokaliseren.

opencode run --agent explore \
  "In deze repository, waar wordt authenticatie gevalideerd voor API-aanvragen? Lijst waarschijnlijke bestanden op en leg de flow uit. Als je onzeker bent, zeg dan wat je hebt gecontroleerd."

Verwachte uitvoer:

  • Een korte kaart van bestandslocaties + flow-beschrijving.
  • Uitvoer hangt af van de repo-grootte en model/aanbieder context-tools.

Workflow: versneld uitvoeren van herhaalde CLI-runs met een persistente server

Als je scripten of meerdere opencode run-oproepen uitvoert, kun je een headless server één keer starten:

Terminal 1:

opencode serve --port 4096 --hostname 127.0.0.1

Terminal 2:

opencode run --attach http://localhost:4096 "Vat de repo-structuur en belangrijkste entrypoints samen."
opencode run --attach http://localhost:4096 "Stel nu 3 high-impact refactors voor en leg uit waarom."

Verwachte uitvoer:

  • Dezelfde als opencode run, maar doorgaans met minder herhaalde start-overhead.

Programmatisch gebruik (officiële JS/TS SDK)

OpenCode exposeert een HTTP-server (OpenAPI) en biedt een type-veilige JS/TS-client.

Installeren:

npm install @opencode-ai/sdk

Voorbeeld: server + client starten, vervolgens prompten

Maak scripts/opencode-sdk-demo.mjs aan:

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

const opencode = await createOpencode({
  hostname: "127.0.0.1",
  port: 4096,
  config: {
    // Model string formaat is provider/model (alleen voorbeeld)
    // model: "anthropic/claude-3-5-sonnet-20241022",
  },
});

console.log(`Server draait op: ${opencode.server.url}`);

// Basis gezondheids-/versiecontrole
const health = await opencode.client.global.health();
console.log("Gezond:", health.data.healthy, "Versie:", health.data.version);

// Een sessie maken en prompten
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: "Genereer een klein README-sectie die deze repo beschrijft." }],
  },
});

console.log(result.data);

// Server sluiten als klaar
opencode.server.close();

Uitvoeren:

node scripts/opencode-sdk-demo.mjs

Verwachte uitvoerstructuur:

  • “Server draait op …”
  • Een gezondheidsreactie inclusief een versiestring
  • Een sessie-prompt reactieobject (exacte structuur hangt af van responseStyle en SDK-versie)

Minimale OpenCode-configuratie om te kopiëren

OpenCode ondersteunt JSON en JSONC-configuratie. Dit is een redelijk startpunt voor een project-lokale configuratie.

Maak opencode.jsonc aan in je repo-root:

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

  // Kies een standaardmodel (provider/model). Houd dit afgestemd op wat `opencode models` toont.
  "model": "provider/model",

  // Optioneel: een goedkoper "klein model" voor lichtgewicht taken (titels, enz.)
  "small_model": "provider/small-model",

  // Optioneel: OpenCode server-standaardwaarden (gebruikt door serve/web)
  "server": {
    "port": 4096,
    "hostname": "127.0.0.1"
  },

  // Optionele veiligheid: bevestiging vereisen voor edits/commando's
  "permission": {
    "edit": "ask",
    "bash": "ask"
  }
}

Korte cheatsheet (snelle referentie)

Commando’s die je dagelijks zult gebruiken

opencode                       # start TUI
opencode run "..."             # niet-interactieve run (automatisering)
opencode run --file path "..." # bestanden aan prompt koppelen
opencode models --refresh      # modellenlijst verversen
opencode auth login            # aanbieder-credentials configureren
opencode serve                 # headless HTTP-server (OpenAPI)
opencode web                   # headless server + web-UI
opencode session list          # sessies tonen
opencode stats                 # token/kosten statistieken

TUI-commando’s om te onthouden

/connect   # een aanbieder verbinden
/init      # repo analyseren, AGENTS.md genereren
/share     # een sessie delen (indien ingeschakeld)
/undo      # een wijziging ongedaan maken
/redo      # een wijziging ongedaan maken
/help      # hulp/sneltoetsen

Standaard “leader key”-concept (TUI)

OpenCode gebruikt een configureerbare “leader”-toets (vaak ctrl+x) om terminal-conflicten te voorkomen. Veel sneltoetsen zijn “Leader + toets”.

Eenzijdige printbare OpenCode cheatsheet tabel

Deze versie is opzettelijk compact en “printvriendelijk”. (Je kunt het later plakken in een dedicate /ai-devtools/opencode/cheatsheet/-pagina.)

Taak Commando / sneltoets Opmerkingen
Start TUI opencode Standaardgedrag is de terminal-UI lanceren
One-shot prompt uitvoeren opencode run "..." Niet-interactieve modus voor scripting/automatisering
Bestand(en) aan prompt koppelen opencode run --file path/to/file "..." Gebruik meerdere --file-vlaggen voor meerdere bestanden
Model kiezen voor een run opencode run --model provider/model "..." Modelstrings zijn provider/model
Agent kiezen opencode run --agent plan "..." Plan is ontworpen voor veiliger “geen wijzigingen” werk (machtiging-beperkt)
Modellen tonen opencode models [provider] Gebruik --refresh om de gecachte lijst bij te werken
Aanbieder-credentials configureren opencode auth login Opslaan credentials in ~/.local/share/opencode/auth.json
Gecertificeerde aanbieders tonen opencode auth list / opencode auth ls Bevestigt wat OpenCode ziet
Headless server starten opencode serve --port 4096 --hostname 127.0.0.1 OpenAPI-spec op http://host:port/doc
Runs koppelen aan server opencode run --attach http://localhost:4096 "..." Handig om herhaalde koude starts te voorkomen
Basisauth inschakelen OPENCODE_SERVER_PASSWORD=... opencode serve Gebruikersnaam is standaard opencode tenzij overruled
Web-UI modus opencode web Start server + opent browser
Sessie exporteren opencode export [sessionID] Handig voor archiveren of context delen
Sessie importeren opencode import session.json Kan ook importeren van een deel-URL
Globale CLI-vlaggen bekijken opencode --help / opencode --version --print-logs + --log-level voor debuggen
TUI leader key concept standaard leader toets vaak ctrl+x Aanpasbaar in tui.json

Oh My Opencode — neem OpenCode verder met multi-agent orchestratie

Zodra OpenCode draait, is de natuurlijke volgende stap Oh My Opencode — een community-plugin die OpenCode omhult in een multi-agent harnas. Het hoofdbegrip: typ ultrawork (of ulw) in een sessie en een orchestrator (Sisyphus) neemt over, delegeert sub-taken aan gespecialiseerde agents die parallel draaien, elk op de model-familie waarvoor hun prompts zijn afgezet.

Drie artikelen bespreken het in diepte:

Bronnen (eerst officiële)

Officieel:

Autoriteit integratieresource:

Gereputeerde vergelijkingen/tutorials:

Abonneren

Ontvang nieuwe berichten over systemen, infrastructuur en AI-engineering.