OpenCode snabbstart: Installera, konfigurera och använd terminalbaserade AI-kodningsagenter

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 valbara gränssnitt för skrivbordet och IDE. Detta är OpenCode Snabbspår: installera, verifiera, koppla en modell/leverantör och kör verkliga arbetsflöden (CLI + API).

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

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

Vad OpenCode är (och var det passar in)

OpenCode är designat för terminalförst, agentbaserad kodning, samtidigt som det förblir flexibelt gällande leverantör och modell. I praktiken är det ett arbetsflödesskikt som kan:

  • starta ett terminalgränssnitt 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 ett webbgränssnitt via opencode web)
  • styras programmatiskt via officiella JS/TS SDK @opencode-ai/sdk

Om du vill jämföra det med en annan öppen källkod agentbaserad assistent som kan utföra flerstegsplaner i en sandlåda, se OpenHands Coding Assistant Snabbspår.

För Anthropic’s terminalförsta agent med samma berättelse om “lokal modell via HTTP” (Ollama eller llama.cpp, behörigheter, prissättning), se Claude Code installation och konfiguration för Ollama, llama.cpp, prissättning.

opencode med self-hosted qwen3.5 27b LLM

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 prenumarationsautentisering, 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 in)

Officiellt installationsskript (Linux/macOS/WSL):

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

Alternativ via paketmanager (officiella exempel):

# Node.js global installation
npm install -g opencode-ai

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

# Arch Linux (stabil)
sudo pacman -S opencode

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

Anteckningar för Windows (officiell vägledning rekommenderar oftast WSL för bästa kompatibilitet). Alternativ inkluderar Scoop/Chocolatey eller npm.

# chocoloatey (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 ett versionsnummer, t.ex. vX.Y.Z>
# <visar hjälp med tillgängliga kommandon/underkommandon>

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

Väg A: TUI /connect (interaktivt)

Starta OpenCode:

opencode

Kör sedan:

/connect

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

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

OpenCode stödjer konfiguration av leverantörer via:

opencode auth login

Anteckningar:

  • Inloggningsuppgifter sparas 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 vilken OpenAI-kompatibel API som helst. För lokal utveckling kör många användare Ollama och pekar OpenCode mot den. Jag hade nyligen mycket god erfarenhet av att konfigurera och köra OpenCode med llama.cpp istället – llama-server exponerar OpenAI-kompatibla endpoints, så du kan använda GGUF-modeller med samma arbetsflöde. Om du föredrar finjusterad kontroll över minne och runtime, eller vill ha en lättare stack utan Python (Ollama är implementerat i Go), är llama.cpp värt att testa. Jag njöt verkligen av möjligheten att konfigurera offloadade lager, enkelheten i användningen av 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 bra inuti OpenCode – över kodninguppgifter 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 ditt repo:

cd /path/to/your/repo
opencode

Initialisera sedan:

/init

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

Centrala CLI-arbetsflöden (kopiera och klistra in-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, parsat 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: refaktorera en fil säkert (CLI + Plan-agent)

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

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

Förväntad utdata:

  • Ett planavsnitt + ett diff --git ...-patchblock + en testchecklista.
  • Innehållet varierar. Om det inte producerar en diff, be om ny prompt: “Returnera bara en unified 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 det här repot, var valideras autentisering för API-förfrågningar? Lista sannolika filer och förklara flödet. Om osäker, säg vad du kontrollerade."

Förväntad utdata:

  • En kort karta över filvägar + flödesbeskrivning.
  • Utdata beror på repos storlek och modell/leverantörs verktyg för kontext.

Arbetsflöde: påskynda upprepade CLI-körningar med en persistent 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 huvud ingångspunkter."
opencode run --attach http://localhost:4096 "Föreslå nu 3 högpåverkande refaktoreringar och varför."

Förväntad utdata:

  • Samma som opencode run, men oftast med mindre upprepad startöverhead.

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: {
    // Modelsträngsformat är leverantör/model (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 snabbspår 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 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å …”
  • En hälsosvar inklusive 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/model). Håll detta i linje med vad `opencode models` visar.
  "model": "leverantör/model",

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

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

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

Kort snabbreferens (snabbspår)

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 modelllista
opencode auth login            # konfigurera leverantörsuppgifter
opencode serve                 # headless HTTP-server (OpenAPI)
opencode web                   # headless server + webbgränssnitt
opencode session list          # lista sessioner
opencode stats                 # token/kostnadsstatistik

TUI-kommandon värt att memorera

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

Konceptet med standard “leader key” (TUI)

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

Ensidig skrivbar OpenCode-snabbreferenstabell

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

Uppgift Kommando / genväg Anteckningar
Starta TUI opencode Standardbeteende är att starta terminalgrä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 en körning opencode run --model leverantör/model "..." Modellsträngar är leverantör/model
Välj agent opencode run --agent plan "..." Plan är designad för säkrare “inga ändringar”-arbete (behörighetsbegränsad)
Lista modeller opencode models [leverantör] Använd --refresh för att uppdatera cachad lista
Konfigurera leverantörsuppgifter opencode auth login Sparar 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
Bifoga körningar till server opencode run --attach http://localhost:4096 "..." Hjälpsam för att undvika upprepade kalla startar
Aktivera grundläggande auth OPENCODE_SERVER_PASSWORD=... opencode serve Användarnamn standard är opencode om inte åsidosatt
Webbgränssnittsläge 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 tangent ofta ctrl+x Anpassningsbar i tui.json

Oh My Opencode – ta OpenCode vidare med multi-agent-orkestrering

När OpenCode är igång är det naturliga nästa steget Oh My Opencode – ett community-tillägg som lindar in OpenCode i en multi-agent-harness. Huvudidén: skriv ultrawork (eller ulw) i en session och en orkestrator (Sisyphus) tar över, delegerar underuppgifter till specialiserade agenter som kör parallellt, var och en på den modellfamilj deras promptar är justerade för.

Tre artiklar täcker det i djupet:

Källor (officiella först)

Officiella:

Auktoritativ integrationsreferens:

Kredibla jämförelser/tutorier:

Prenumerera

Få nya inlägg om system, infrastruktur och AI-ingenjörskonst.