OpenCode snabbstart: Installera, konfigurera och använd terminal-AI-kodningsagenten

Hur du installerar, konfigurerar och använder OpenCode

Sidinnehåll

OpenCode är en öppen källkods-AI-agent för kodning som du kan köra i terminalen (TUI + CLI) med valbara skrivbords- och IDE-ytor. Detta är OpenCode-quickstarten: installera, verifiera, anslut en modell/leverantör och kör verkliga arbetsflöden (CLI + API).

Versionsnotering: OpenCode släpper snabbt. De “senaste” kommandona här är stabila, men utdata och standardvärden kan ändras – kontrollera alltid officiella CLI-dokumentation och ändringslogg (länkar nedan).

Den här artikeln är en del av AI-utvecklarverktyg: Den kompletta guiden till AI-driven utveckling.

Vad OpenCode är (och var det hör hemma)

OpenCode är designat för terminal-first, agentbaserad kodning, samtidigt som det är flexibelt gällande leverantör och modell. I praktiken är det ett lager för arbetsflöden som kan:

  • starta en terminalanvändargränssnitt (TUI) när du kör opencode
  • köra icke-interaktiva “one-shot”-promptar via opencode run (skript/automatisering)
  • exponera en headless HTTP-server via opencode serve (och en webbanvändargränssnitt via opencode web)
  • styras programmatiskt via den officiella JS/TS-SDK:n @opencode-ai/sdk

Om du vill jämföra det med en annan öppen källkods-agent för kodning som kan utföra flertrinsplaner i en innesluten miljö, se OpenHands Coding Assistant QuickStart.

opencode with self-hosted qwen3.5 27b LLM

Om du bygger en /ai-devtools/-kluster är OpenCode en stark kandidat för en underkluster eftersom den naturligt expanderar in i:

  • CLI-djupdykning
  • modell- och leverantörbeteende samt kostnader (LLM-jämförelse inuti OpenCode)
  • konfiguration & agenter
  • integrationer (GitHub/GitLab/Copilot)
  • fuskblad
  • Oh My Opencode — ett lager för orkestrering av flera agenter byggt på OpenCode

Förutsättningar

Du behöver:

  • En modern terminal-emulator (viktigt för TUI-upplevelsen).
  • Tillgång till minst en modell/leverantör (API-nycklar eller prenumarationsbaserad autentisering, 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)

Officiellt installationsskript (Linux/macOS/WSL):

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

Alternativ för paketförvaltare (officiella exempel):

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

# Homebrew (rekommenderas av OpenCode för de senaste släppen)
brew install anomalyco/tap/opencode

# Arch Linux (stabil)
sudo pacman -S opencode

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

Noteringar för Windows (officiell vägledning 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äntad utdata (varierar beroende på version):

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

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

Väga A: TUI /connect (interaktivt)

Starta OpenCode:

opencode

Kör sedan:

/connect

Följ stegen i användargränssnittet för att välja en leverantör och autentisera (vissa flöden öppnar en webbläsare eller inloggning för enhet).

Väga B: CLI opencode auth login (leverantörsnycklar)

OpenCode stöder konfiguration av leverantörer via:

opencode auth login

Noteringar:

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

Lokalt LLM-värd (Ollama, llama.cpp)

OpenCode fungerar med vilket OpenAI-kompatibelt API som helst. För lokal utveckling kör många användare Ollama och pekar OpenCode mot det. Jag hade nyligen mycket bra erfarenhet av att konfigurera och köra OpenCode med llama.cpp istället – llama-server exponerar OpenAI-kompatibla ändpunkter, så du kan använda GGUF-modeller med samma arbetsflöde. Om du föredrar finjusterad kontroll över minne och körning, eller vill ha en lättare stack utan Python (Ollama är för övrigt implementerat i Go), är llama.cpp värt att testa. Jag njöt verkligen av möjligheten att konfigurera offloaded lager, användarvänligheten för modeller i GGUF-format och mycket bättre/snabbare implementerad kompatibilitet med nya modeller, som Qwen3.5. Om du vill veta vilka modeller som faktiskt presterar väl inuti OpenCode – över kodningssysslor och noggrannhet i strukturerad utdata – se min praktiska LLM-jämförelse för OpenCode.

Starta ett projekt korrekt (rekommenderad första körning)

Från din repo:

cd /path/to/your/repo
opencode

Initiera sedan:

/init

Detta analyserar ditt projekt och skapar en AGENTS.md-fil i projektrot. Det är värt att commita den här filen så att OpenCode (och kollegor) delar en konsistent projektkontext.

Grundläggande CLI-arbetsflöden (exempel att kopiera)

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, parsar ett int, validera 1-65535, och returnera defaultPort om tom. Inkludera 3 tabelldrivna tester."

Förväntad utdata:

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

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

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

opencode run --agent plan --file ./src/auth.ts \
  "Refactora den här filen för att minska komplexiteten. Utdata: (1) en kort plan, (2) ett enhetligt diff-patch, (3) risker/gränsfall att testa. Kör inte kommandon."

Förväntad utdata:

  • Ett plansnitt + ett diff --git ...-patchblock + en testchecklista.
  • Innehåll varierar. Om det inte producerar ett diff, be om det igen: “Returnera endast ett enhetligt diff” eller “Använd diff --git-formatet.”

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

Mål: hitta implementeringsdetaljer snabbt.

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

Förväntad utdata:

  • En karta över filvägar + flödesbeskrivning.
  • Utdata beror på repos storlek och modell/leverantör-kontextverktyg.

Arbetsflöde: påskynda upprepade CLI-körningar med en bestående server

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 repos struktur och huvudentry points."
opencode run --attach http://localhost:4096 "Förslag nu 3 högimpakterande refactoringar och varför."

Förväntad utdata:

  • Samma som opencode run, men vanligtvis med mindre upprepad startkostnad.

Programmatisk användning (officiell JS/TS-SDK)

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

Installera:

npm install @opencode-ai/sdk

Exempel: starta server + klient, sedan prompta

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ängsformat är leverantör/modell (endast exempel)
    // model: "anthropic/claude-3-5-sonnet-20241022",
  },
});

console.log(`Servern kör på: ${opencode.server.url}`);

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

// Skapa en session och prompta
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 ett litet README-snitt som beskriver detta repo." }],
  },
});

console.log(result.data);

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

Kör:

node scripts/opencode-sdk-demo.mjs

Förväntad utdatastruktur:

  • “Servern kör på …”
  • Ett hälsosvar som inkluderar en versionssträng
  • Ett sessionsprompt-svarsobjekt (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 projektlokal konfiguration.

Skapa opencode.jsonc i din repos rot:

{
  "$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ätta uppgifter (titlar, etc.)
  "small_model": "leverantör/liten-modell",

  // Valfria standardvärden för OpenCode-server (används av serve/web)
  "server": {
    "port": 4096,
    "hostname": "127.0.0.1"
  },

  // Valfri säkerhet: kräv bekräftelse före redigeringar/kommandon
  "permission": {
    "edit": "ask",
    "bash": "ask"
  }
}

Kort fuskblad (snabb referens)

Kommandon du kommer använda dagligen

opencode                       # starta TUI
opencode run "..."             # icke-interaktiv körning (automatisering)
opencode run --file path "..." # bifoga filer till prompt
opencode models --refresh      # uppdatera modellista
opencode auth login            # konfigurera leverantörsuppgifter
opencode serve                 # headless HTTP-server (OpenAPI)
opencode web                   # headless server + webbanvändargränssnitt
opencode session list          # lista sessioner
opencode stats                 # token/kostnadsstatistik

TUI-kommandon värt att memorera

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

Konceptet “leader key” (TUI)

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

Ensidigt, utskriftsvänligt OpenCode-fuskblad

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

Uppgift Kommando / genväg Noteringar
Starta TUI opencode Standardbeteende är att starta terminalanvändargränssnittet
Kör en “one-shot”-prompt opencode run "..." Icke-interaktivt läge för skript/automatisering
Bifoga fil(er) till prompt opencode run --file path/to/file "..." Använd flera --file-flaggor för flera filer
Välj modell för körning opencode run --model leverantör/modell "..." Modellsträngar är leverantör/modell
Välj agent opencode run --agent plan "..." Plan är designad för säkrare “inga ändringar”-arbete (tillåtelsebegränsad)
Lista modeller opencode models [leverantör] Använd --refresh för att uppdatera cachad lista
Konfigurera leverantörsuppgifter opencode auth login Lagrar uppgifter 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 på http://host:port/doc
Koppla körningar till server opencode run --attach http://localhost:4096 "..." Hjälpsam för att undvika upprepade kalla startar
Aktivera grundläggande autentisering OPENCODE_SERVER_PASSWORD=... opencode serve Användarnamn standard är opencode om inte åsidosatt
Läge för webbanvändargränssnitt opencode web Startar server + öppnar webbläsare
Exportera en session opencode export [sessionID] Nyttigt för arkivering eller delning av kontext
Importera en session opencode import session.json Kan också importera från en delnings-URL
Visa globala CLI-flaggor opencode --help / opencode --version --print-logs + --log-level för felsökning
TUI-leader-key-koncept standard leader-key är ofta ctrl+x Anpassningsbar i tui.json

Oh My Opencode – ta OpenCode vidare med orkestrering av flera agenter

När OpenCode är igång är det naturliga nästa steget Oh My Opencode — ett community-plugin som innesluter OpenCode i ett harness för flera agenter. Huvudidén: skriv ultrawork (eller ulw) i en session och en orkestrator (Sisyphus) tar över och delegerar deluppgifter till specialiserade agenter som kör parallellt, var och en på modellfamiljen som dess promptar är justerade för.

Tre artiklar täcker det i djupet:

Källor (officiella först)

Officiella:

Auktoritativ integrationsreferens:

Pålitliga jämförelser/guider: