OpenCode Snabbstart: Installera, konfigurera och använd terminalens AI-kodningsagent

Hur man installerar, konfigurerar och använder OpenCode

Sidinnehåll

OpenCode är en öppen källkod AI-kodningsagent som du kan köra i terminalen (TUI + CLI) med valfria skrivbords- och IDE-ytor. Detta är den OpenCode Quickstart: installera, verifiera, anslut en modell/leverantör och kör verkliga arbetsflöden (CLI + API).

Versionsnote: OpenCode levererar snabbt. De här kommandona som är “senaste” är stabila, men utdata och standardvärden kan ändras – kontrollera alltid officiella CLI-dokumentationen och changelog (länkade nedan).

Detta artikel är en del av AI Developer Tools: The Complete Guide to AI-Powered Development.

Vad OpenCode är (och varför det passar)

OpenCode är designat för terminalförst, agentbaserad kodning, medan det är modell/leverantörsflexibelt. I praktiken är det en arbetsflödeslager som kan:

  • starta en terminalgränssnitt när du kör opencode
  • köra interaktiva “one-shot” prompt via opencode run (skript/automatisering)
  • exponera en headless HTTP-server via opencode serve (och en webbgränssnitt via opencode web)
  • kontrolleras programmerat via den officiella JS/TS SDK @opencode-ai/sdk

opencode med self-hosted qwen3.5 27b LLM

Om du bygger en /ai-devtools/ kluster, är OpenCode ett starkt alternativ för en underkluster eftersom det naturligt utvecklas till:

  • CLI djupdykning
  • modell/leverantörsbeteende och kostnader (LLM jämförelse inom OpenCode)
  • konfiguration & agenter
  • integreringar (GitHub/GitLab/Copilot)
  • cheatlista

Förutsättningar

Du kommer att vilja ha:

  • En modern terminalsimulator (viktigt för TUI-erfarenheten).
  • Åtkomst till minst en modell/leverantör (API-nycklar eller prenumerationsautentisering, beroende på leverantör). Lokala alternativ som Ollama eller llama.cpp fungerar utan API-nycklar när du kör en kompatibel server lokalt.

Installera OpenCode (kopiera och klistra)

Officiell installationskript (Linux/macOS/WSL):

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

Pakethanteringsalternativ (officiella exempel):

# Global installation with Node.js
npm install -g opencode-ai

# Homebrew (rekommenderas av OpenCode för de mest uppdaterade versionerna)
brew install anomalyco/tap/opencode

# Arch Linux (stabil)
sudo pacman -S opencode

# Arch Linux (senaste från AUR)
paru -S opencode-bin

Windows-anteckningar (officiell riktlinje rekommenderar ofta WSL för bästa kompatibilitet). Alternativ inkluderar Scoop/Chocolatey eller npm.

# Chocolatey (Windows)
choco install opencode

# Scoop (Windows)
scoop install opencode

Docker (nyttigt för en snabb test):

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

Verifiera installationen

opencode --version
opencode --help

Förväntat utdataformat (varierar beroende på version):

# Exempel:
# <skriver ut en versionsnummer, t.ex. vX.Y.Z>
# <skriver ut hjälp med tillgängliga kommandon/underkommandon>

Anslut en leverantör (två praktiska vägar)

Sökväg A: TUI /connect (interaktiv)

Starta OpenCode:

opencode

Sedan kör:

/connect

Följ UI-stegen för att välja en leverantör och autentisera (vissa flöden öppnar en webbläsare/enhet login).

Sökväg B: CLI opencode auth login (leverantörsnycklar)

OpenCode stöder konfigurera leverantörer via:

opencode auth login

Anteckningar:

  • Autentiseringsuppgifter lagras vid ~/.local/share/opencode/auth.json.
  • OpenCode kan också ladda nycklar från miljövariabler eller en .env-fil i ditt projekt.

Lokal LLM-verktyg (Ollama, llama.cpp)

OpenCode fungerar med alla OpenAI-kompatibla API:er. För lokal utveckling använder många användare Ollama och pekar OpenCode på den. Jag har nyligen haft mycket goda upplevelser med att konfigurera och köra OpenCode med llama.cpp istället – llama-server exponerar OpenAI-kompatibla slutpunkter, så du kan använda GGUF-modeller med samma arbetsflöde. Om du föredrar finjusterad kontroll över minne och körningstid, eller vill ha en lättare stack utan Python (BTW, ollama är implementerad i Go), är llama.cpp värt att prova. Jag njöt mycket av möjligheten att konfigurera avlastade lager, användbarhet av modeller i GGUF-format, och mycket bättre/fasare implementerad kompatibilitet med nya modeller, som Qwen3.5.

Starta ett projekt korrekt (rekommenderas först körs)

Från din repo:

cd /path/to/your/repo
opencode

Sedan initiera:

/init

Detta analyserar ditt projekt och skapar en AGENTS.md-fil i projektets rot. Det är vanligtvis värt att committa denna fil så att OpenCode (och kollegor) delar konsistent projektkontext.

Core CLI-arbetsflöden (kopiera och klistra exempel)

OpenCode stöder icke-interaktiva körningar:

opencode run "Förklara hur closures fungerar i JavaScript"

Arbetsflöde: generera kod (CLI)

Mål: generera en liten, testbar funktion med minimal kontext.

opencode run "Skriv en Go-funktion ParsePort(envVar string, defaultPort int) (int, error). Den ska läsa miljövariabeln, tolka en int, validera 1-65535, och returnera defaultPort om tom. Inkludera 3 tabellbaserade tester."

Förväntat utdata:

  • En förklaring plus kodblock (funktion + tester). Exakt kod varierar beroende på modell/leverantör och prompt.

Arbetsflöde: omstrukturera en fil säkert (CLI + Plan agent)

Mål: omstrukturera utan oavsiktliga redigeringar genom att använda en mer restriktiv agent.

opencode run --agent plan --file ./src/auth.ts \
  "Omstrukturera den här filen för att minska komplexitet. Utdata: (1) en kort plan, (2) en sammanfogad diff-patch, (3) risker/kantfall att testa. Kör inte kommandon."

Förväntat utdata:

  • En planavsnitt + en diff --git ...-patchblock + en testchecklista.
  • Innehåll varierar. Om den inte producerar en diff, omfråga: “Returnera endast en sammanfogad diff” eller “Använd diff --git-format.”

Arbetsflöde: ställ frågor om repo (CLI)

Mål: snabbt hitta implementeringsdetaljer.

opencode run --agent explore \
  "I detta rep, var valideras autentisering för API-begäranden? Lista troliga filer och förklara flödet. Om osäker, säg vad du kontrollerade."

Förväntat utdata:

  • En kort karta över filvägar + flödesbeskrivning.
  • Utdata beror på repstorlek och modell/leverantörs kontextverktyg.

Arbetsflöde: förbättra upprepade CLI-körningar med en persistenserver

Om du skriptar eller kör flera opencode run-anrop kan du starta en headless server en gång:

Terminal 1:

opencode serve --port 4096 --hostname 127.0.0.1

Terminal 2:

opencode run --attach http://localhost:4096 "Sammanfatta repostrukturen och huvudsakliga ingångspunkter."
opencode run --attach http://localhost:4096 "Föreslå nu 3 högverkande omstruktureringar och varför."

Förväntat utdata:

  • Samma som opencode run, men vanligtvis med mindre upprepade startöverhuvud.

Programmatisk användning (officiell JS/TS SDK)

OpenCode exponerar en HTTP-server (OpenAPI) och tillhandahåller en typsäker JS/TS-klient.

Installera:

npm install @opencode-ai/sdk

Exempel: starta server + klient, sedan prompt

Skapa scripts/opencode-sdk-demo.mjs:

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

const opencode = await createOpencode({
  hostname: "127.0.0.1",
  port: 4096,
  config: {
    // Modellsträngformat är leverantör/modell (endast exempel)
    // model: "anthropic/claude-3-5-sonnet-20241022",
  },
});

console.log(`Server kör vid: ${opencode.server.url}`);

// Grundläggande hälsotest/version
const health = await opencode.client.global.health();
console.log("Hälsocheck:", health.data.healthy, "Version:", health.data.version);

// Skapa en session och prompt
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: "Generera en liten README-sektion som beskriver detta repo." }],
  },
});

console.log(result.data);

// Stäng server när du är klar
opencode.server.close();

Kör:

node scripts/opencode-sdk-demo.mjs

Förväntat utdataformat:

  • “Server kör vid …”
  • En hälsorespons inklusive en versionssträng
  • En sessionspromptresponsobjekt (exakt struktur beror på responseStyle och SDK-version)

Minimal OpenCode konfiguration du kan kopiera

OpenCode stöder JSON och JSONC-konfiguration. Detta är en rimlig startpunkt för en projektlokalt konfiguration.

Skapa opencode.jsonc i din repo-root:

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

  // Välj en standardmodell (leverantör/modell). Håll detta i linje med vad `opencode models` visar.
  "model": "leverantör/modell",

  // Valfritt: en billigare “liten modell” för lättare uppgifter (titlar, etc.)
  "small_model": "leverantör/liten-modell",

  // Valfritt: OpenCode serverstandardvärden (används av serve/web)
  "server": {
    "port": 4096,
    "hostname": "127.0.0.1"
  },

  // Valfritt säkerhet: kräv bekräftelse innan redigeringar/kommandon
  "permission": {
    "edit": "fråga",
    "bash": "fråga"
  }
}

Kort cheatlista (snabbreferens)

Kommandon du kommer använda varje dag

opencode                       # starta TUI
opencode run "..."             # icke-interaktiv körning (automatisering)
opencode run --file path "..." # koppla filer till prompt
opencode models --refresh      # uppdatera modelllista
opencode auth login            # konfigurera leverantörsautentisering
opencode serve                 # headless HTTP-server (OpenAPI)
opencode web                   # headless server + webbgränssnitt
opencode session list          # lista sessioner
opencode stats                 # token/kostnad statistik

TUI-kommandon värt att minnas

/connect   # anslut en leverantör
/init      # analysera repo, generera AGENTS.md
/share     # dela en session (om aktiverat)
/undo      # ångra en ändring
/redo      # återgöra en ändring
/help      # hjälp/shortcuts

Standard “leader key” koncept (TUI)

OpenCode använder en konfigurerbar “leader”-nyckel (ofta ctrl+x) för att undvika terminalkonflikter. Många snabbtangentkommandon är “Leader + nyckel”.

En-sidig skrivbar OpenCode cheatlista tabell

Den här versionen är avsiktligt tät och “skrivbar”. (Du kan klistra in den i en dedikerad /ai-devtools/opencode/cheatsheet/ sida senare.)

Uppgift Kommando / snabbtangent Anteckningar
Starta TUI opencode Standardbeteende är att starta terminalgränssnittet
Kör en one-shot prompt opencode run "..." Icke-interaktivt läge för skriptning/automatisering
Koppla filer till prompt opencode run --file path/to/file "..." Använd flera --file-flaggor för flera filer
Välj modell för en körning opencode run --model provider/model "..." Modellsträngar är provider/model
Välj agent opencode run --agent plan "..." Plan är designad för säkrare “ingen ändring” arbete (tillåtningsbegränsad)
Lista modeller opencode models [provider] Använd --refresh för att uppdatera cachelista
Konfigurera leverantörsautentisering opencode auth login Lagrar autentiseringsuppgifter i ~/.local/share/opencode/auth.json
Lista autentiserade leverantörer opencode auth list / opencode auth ls Bekräftar vad OpenCode ser
Starta headless server opencode serve --port 4096 --hostname 127.0.0.1 OpenAPI-specifikation vid http://host:port/doc
Koppla körningar till server opencode run --attach http://localhost:4096 "..." Något som kan vara användbart för att undvika upprepade kalla startar
Aktivera grundläggande autentisering OPENCODE_SERVER_PASSWORD=... opencode serve Standardanvändare är opencode om inte åsidosatt
Webbgränssnittsmodus opencode web Startar server + öppnar webbläsare
Exportera en session opencode export [sessionID] Något som kan vara användbart för arkivering eller delning av kontext
Importera en session opencode import session.json Kan också importera från en delningslänk
Visa globala CLI-flaggor opencode --help / opencode --version --print-logs + --log-level för felsökning
TUI leader key koncept standard leader-nyckel ofta ctrl+x Kan anpassas i tui.json

Källor (officiella först)

Officiella:

Mycket myndig integrationsreferens:

Reputabel jämförelse/tutorier: