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

Hur man installerar, konfigurerar och använder OpenCode

Sidinnehåll

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

Versionsnotering: OpenCode släpps snabbt. De “senaste” kommandona här är stabila, men utdata och standardinställningar kan ändras – kontrollera alltid den officiella CLI-dokumentationen och ändringsloggen (länkad nedan).

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

Vad OpenCode är (och var det passar in)

OpenCode är designat för terminalfokuserad, agentbaserad kodning, samtidigt som det förblir flexibelt gällande leverantör/modell. I praktiken är det ett arbetsflödeslager som kan:

  • starta ett terminalgränssnitt (TUI) när du kör opencode
  • köra icke-interaktiva “ensprångs”-promptar via opencode run (skript/automatisering)
  • exponera en headless HTTP-server via opencode serve (och ett webbläsargränssnitt via opencode web)
  • styras programmatiskt via det officiella JS/TS-SDK:t @opencode-ai/sdk

Om du vill jämföra det med en annan öppen källkods-agentassistent som kan utföra flerstegsplaner i en sandbåxmiljö, se OpenHands Coding Assistant QuickStart.

För Anthrups terminalfokuserade 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 självhostad qwen3.5 27b LLM

Förutsättningar

Du kommer att behöva:

  • En modern terminal emulator (viktigt för TUI-upplevelsen).
  • Åtkomst till minst en modell/leverantör (API-nycklar eller prenumerationautentisering, 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-klistra)

Officiellt installationsskript (Linux/macOS/WSL):

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

Paketmanager-alternativ (officiella exempel):

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

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

# Arch Linux (stabilt)
sudo pacman -S opencode

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

Noteringar för Windows (officiell vägledning rekommenderar vanligtvis WSL för bäst kompatibilitet). Alternativen inkluderar Scoop/Chocolatey eller npm.

# chocolatey (Windows)
choco install opencode

# scoop (Windows)
scoop install opencode

Docker (nyttigt för ett snabbt prov):

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

Verifiera installation

opencode --version
opencode --help

Förväntad utdatastruktur (varierar beroende på version):

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

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

Väg A: TUI /connect (interaktivt)

Starta OpenCode:

opencode

Kör sedan:

/connect

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

Väg 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.

Lokal LLM-hostning (Ollama, llama.cpp)

OpenCode fungerar med alla OpenAI-kompatibla APIs. För lokal utveckling kör många användare Ollama och pekar OpenCode på den. Jag har nyligen haft mycket bra erfarenheter 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 (OBS: Ollama är implementerad i Go), är llama.cpp värt ett försök. Jag uppskattade verkligen möjligheten att konfigurera offladde lager, användarvänligheten hos modellerna i GGUF-format, och den mycket bättre/snabbare implementerade kompatibiliteten med nya modeller, som Qwen3.5. Om du vill veta vilka modeller som faktiskt presterar bra i OpenCode – över kodninguppgifter och noggrannhet för strukturerad utdata – se min praktiska LLM-jämförelse för OpenCode.

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

Från ditt repo:

cd /path/to/your/repo
opencode

Initiera sedan:

/init

Detta analyserar ditt projekt och skapar en AGENTS.md-fil i projektrotsmappen. Det är oftast värt att committa denna fil så att OpenCode (och medarbetare) delar en konsekvent projektkontext.

Kärn CLI-arbetsflöden (exempel att kopiera-klistra)

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 en int, validera 1-65535, och returnera defaultPort om den är tom. Inkludera 3 tabell-drivna 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 ändringar genom att använda en mer restriktiv agent.

opencode run --agent plan --file ./src/auth.ts \
  "Refactora denna fil för att minska komplexiteten. Utdata: (1) en kort plan, (2) en enhetlig diff-patch, (3) risker/kantfall att testa. Kör inga kommandon."

Förväntad utdata:

  • Ett planavsnitt + ett diff --git ... patch-block + en testchecklista.
  • Innehållet varierar. Om det inte producerar en diff, prompta igen: “Returnera endast en enhetlig diff” eller “Använd diff --git-format.”

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

Mål: lokalisera implementeringsdetaljer snabbt.

opencode run --agent explore \
  "I detta repository, var valideras autentiseringen 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 kort karta över filvägar + flödesbeskrivning.
  • Utdata beror på repos storlek och modell/leverantörs kontextverktyg.

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 repo-strukturen och huvudentrapparna."
opencode run --attach http://localhost:4096 "Föreslå nu 3 högpåverkande refaktoreringsförslag och varför."

Förväntad utdata:

  • Samma som opencode run, men oftast med mindre upprepade startkostnader.

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

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

// Grundläggande hälsokontroll/version
const health = await opencode.client.global.health();
console.log("Frisk:", 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-avsnitt 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örs på…”
  • Ett hälsosvar som innehåller 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 repo-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": "provider/model",

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

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

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

Kort cheatssheet (snabbreferens)

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 modellistan
opencode auth login            # konfigurera leverantörsinloggningsuppgifter
opencode serve                 # headless HTTP-server (OpenAPI)
opencode web                   # headless server + web UI
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 aktiverad)
/undo      # ångra en ändring
/redo      # gör om en ändring
/help      # hjälp/genvägar

Standard “leader key”-koncept (TUI)

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

En-sidig utskrivbar OpenCode-cheatssheet-tabell

Denna version ä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 Standardbeteendet är att starta terminal-UI:t
Kör ensprångsprompt 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 provider/model "..." Modellsträngar är leverantör/modell
Välj agent opencode run --agent plan "..." Plan är designad för säkrare “inga ändringar”-arbete (behörighetsbegränsad)
Lista modeller opencode models [provider] Använd --refresh för att uppdatera cachad lista
Konfigurera leverantörsinloggningsuppgifter opencode auth login Lagrar inloggningsuppgifter 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älpsamt för att undvika upprepade kalla starter
Aktivera grundläggande autentisering OPENCODE_SERVER_PASSWORD=... opencode serve Användarnamn standardiserar till opencode om inte åsidosatt
Web UI-läge opencode web Startar server + öppnar webbläsare
Exportera en session opencode export [sessionID] Användbart 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 ofta ctrl+x Anpassningsbar i tui.json

Oh My Opencode — ta OpenCode vidare med multi-agent-orchestrering

När OpenCode är igång är det naturliga nästa steget Oh My Opencode — ett community-plugin som wrappar OpenCode i en multi-agent-harness. Huvudidén: skriv ultrawork (eller ulw) i en session och en orchestrator (Sisyphus) tar över, delegerar deluppgifter till specialiserade agenter som körs parallellt, var och en på den modellfamilj deras prompts är anpassade för.

Tre artiklar täcker det i djupet:

OpenCode var ett av de första verktygen som påverkades av Anthrups policy att blockera tredjeparts-åtkomst till Claude-prenumerationer – ett beslut gjort i januari 2026, en månad innan samma begränsning träffade OpenClaw. OpenClaw-uppgång och fall-tidslinjen dokumenterar båda händelserna och det bredare mönster de representerar för agentverktyg byggda på prenumerationsberäkning.

Källor (officiella först)

Officiella:

Autentisk integreringsreferens:

Respektabla jämförelser/tutorials:

Prenumerera

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