Ollama: 6 Kodemodeller Lokalt I 14 Trin, 70 Min [2026]

Ollama er blevet den mest udbredte måde at køre AI-kodemodeller lokalt på egen maskine, uden at sende en linje kode til en cloud-tjeneste. Værktøjet er oppe i version 0.40.0 i skrivende stund, og biblioteket af kodemodeller er vokset markant i 2026, fra Qwen2.5-Coder og det nyere Qwen3-Coder til DeepSeek-Coder-V2, Codestral, StarCoder2 og CodeGemma. Denne guide tager dig gennem hele opsætningen i 14 konkrete trin, fra installation til et færdigt, kørende projekt.

Du ender med en lokal kodeassistent, der svarer på forespørgsler via et REST-API, kan kobles til VS Code, og som kører helt uden internetforbindelse, når modellen først er hentet. Vi bygger samtidig et konkret eksempelprojekt, en lille kommandolinje-assistent der skriver git commit-beskeder for dig ud fra dine faktiske kodeændringer, så du ikke bare læser teori, men ser modellen arbejde på rigtig kode.

Guiden er skrevet til udviklere, der allerede kender terminalen, men som ikke har kørt en lokal LLM før. Du behøver ikke en kraftig gaming-maskine for at komme i gang. Vi viser dig, hvordan du vælger en model, der faktisk matcher din hardware, i stedet for at downloade den største model og ende med en computer, der fryser fast.

Vi dækker både den hurtige vej (en kommando, en model, et svar i terminalen) og den mere grundige opsætning, hvor du kører Ollama som en delt tjeneste, kobler den til din editor, og bygger et rigtigt værktøj ovenpå API’et. Undervejs får du to tabeller til at vælge model og hardware ud fra, en komplet liste med fejlfindingsscenarier, og en gennemgang af, hvad du skal overveje omkring datahåndtering, hvis du arbejder i en dansk virksomhed med compliance-krav.

Hvad er Ollama, og hvorfor skal du køre kodemodeller lokalt?

Ollama er et open source-værktøj, der pakker store sprogmodeller ind i en simpel kommandolinje-oplevelse. I stedet for selv at håndtere Python-miljøer, CUDA-biblioteker og modelvægte i forskellige formater, giver Ollama dig en enkelt kommando til at hente og køre en model, plus en lokal server, der eksponerer modellen via et REST-API på http://localhost:11434. Projektet er open source og ligger offentligt på GitHub, hvor du også kan følge med i, hvornår nye versioner lander.

Den store motivation for at køre kodemodeller lokalt er tredelt. Først er der privatliv: din kildekode forlader aldrig maskinen, hvilket betyder noget, hvis du arbejder med forretningshemmeligheder, uudgivne features eller kunders data i testmiljøer. Dernæst er der pris. Når modellen kører på din egen GPU eller CPU, betaler du strøm, ikke en pris pr. token eller et abonnement. Til sidst er der kontrol: du vælger selv model, kontekstvindue og systemprompt, og du er ikke afhængig af, at en tjeneste er nede, eller at en leverandør ændrer vilkårene.

Det betyder ikke, at lokale modeller slår cloud-baserede assistenter som GitHub Copilot eller Claude Code på rå kodekvalitet, især ikke på svære, flertrins-opgaver. Men til autocomplete, kodeforklaring, commit-beskeder, dokumentation og mange daglige opgaver er forskellen ofte mindre, end man tror, og fordelen ved at have kontrol over egen infrastruktur vejer tungt for mange teams og enkeltudviklere. Ollama er samtidig blevet standardvalget, netop fordi det gør skiftet mellem modeller til en étlinjes-kommando i stedet for et helt nyt opsætningsprojekt.

Det, der for alvor har gjort lokale kodemodeller brugbare i 2026, er ikke kun Ollama selv, men væksten i åbne modelvægte fra forskere og selskaber som Alibaba (Qwen-serien), DeepSeek, Mistral (Codestral) og BigCode (StarCoder2). Disse modeller udgives med vægte, alle kan downloade og køre selv, i modsætning til lukkede modeller der kun er tilgængelige via et API. Ollama fungerer som limen mellem de åbne modelvægte og din maskine, og pakker alt det tekniske setup (quantisering, GPU-offloading, tokenisering) ind i kommandoer, der føles lige så simple som at installere en almindelig app.

Forudsætninger: hardware, styresystem og software-versioner

Før du installerer noget, bør du afklare hvilken model du realistisk kan køre. Det er den enkeltstående faktor, der afgør, om oplevelsen bliver flydende eller frustrerende langsom. Ollama kører på Linux, macOS og Windows, og kræver ingen GPU for at fungere, men en GPU gør en enorm forskel i hastighed.

Har du en Nvidia-GPU, bør du have en opdateret driver installeret, så Ollama automatisk kan finde og bruge CUDA. Har du en Mac med Apple Silicon (M-serie), bruger Ollama Metal-acceleration automatisk, og den unified memory-arkitektur betyder, at CPU og GPU deler den samme hukommelsespulje, hvilket gør det muligt at køre overraskende store modeller på en bærbar. AMD-GPU’er understøttes via ROCm på udvalgte kort og Linux-distributioner. Tjek kompatibiliteten på AMD’s ROCm-dokumentation, før du forventer GPU-acceleration på et AMD-kort.

Du behøver desuden en terminal (Bash, Zsh eller PowerShell), og hvis du vil følge projektdelen senere i guiden, skal du have Git installeret. Resten af forudsætningerne, selve modellerne, henter vi undervejs, så du ikke downloader noget, du ikke ender med at bruge.

Det er også værd at afsætte lidt tid, før du går videre. Selve installationen af Ollama tager typisk under fem minutter, men hvis du skal hente en 30b-klasse model på en almindelig fiberforbindelse, kan downloadet alene tage 15-30 minutter. Planlægger du at følge hele guiden fra start til slut, inklusive VS Code-integrationen og det afsluttende projekt, bør du afsætte omkring 60-70 minutter i alt, afhængigt af din internethastighed og hvor mange modeller du vælger at teste undervejs.

Trin 1-2: Installer Ollama på Linux, macOS og Windows

Installationen er bevidst gjort enkel, uanset platform. På Linux bruger du det officielle installationsscript direkte fra terminalen:

# Linux: officiel installation
curl -fsSL https://ollama.com/install.sh | sh

# Bekræft at det virkede
ollama --version

På macOS downloader du Ollama-applikationen fra ollama.com og flytter den til din Programmer-mappe, ligesom med enhver anden Mac-app. Foretrækker du en pakkehåndtering, kan du i stedet bruge Homebrew:

# macOS via Homebrew
brew install --cask ollama

# Bekræft version
ollama --version
ollama run qwen2.5-coder:7b

På Windows henter du den officielle installer fra samme hjemmeside og kører den som enhver anden .exe-installation. Bagefter åbner du PowerShell og tjekker, at kommandolinje-klienten er tilgængelig:

# Windows PowerShell
ollama --version
ollama run qwen2.5-coder:7b

Uanset platform installerer Ollama sig selv som en baggrundstjeneste, så du ikke behøver at starte en server manuelt hver gang du genstarter maskinen. Det eneste, du typisk selv skal gøre bagefter, er at hente de modeller, du vil bruge, hvilket vi gør i trin 4.

Trin 3: Start serveren og bekræft installationen

Som standard lytter Ollama på port 11434, og i de fleste installationer starter serveren automatisk som en baggrundsproces. Hvis den ikke gør, eller hvis du har afinstalleret autostart, kan du starte den manuelt:

# Start Ollama-serveren manuelt, hvis den ikke allerede kører
ollama serve

Åbn en ny terminal (lad ollama serve køre i den gamle, hvis du startede den manuelt), og test forbindelsen:

curl http://localhost:11434/api/tags

Et korrekt svar ligner dette, med en liste over de modeller du allerede har installeret (tom, hvis det er første gang):

{
  "models": []
}

Får du i stedet en fejl som “connection refused”, er serveren ikke startet, eller en firewall blokerer localhost-trafik. Vi kommer tilbage til præcis den fejl i fejlfindings-afsnittet senere i guiden.

Trin 4-5: Vælg og hent den rigtige kodemodel til din hardware

Det vigtigste valg i hele opsætningen er, hvilken model du starter med. Ollamas modelbibliotek har flere familier målrettet specifikt kodning, og de adskiller sig markant i størrelse, hukommelsesbehov og kontekstvindue.

En kort forklaring på tallene i tabellen: “7b” betyder, at modellen har omkring 7 milliarder parametre. Flere parametre betyder generelt bedre forståelse af nuancer og sjældnere fejl, men også et markant større hukommelsesforbrug og langsommere svar. De fleste modeller i Ollamas bibliotek er desuden quantiserede, det vil sige komprimerede til et lavere præcisionsniveau, så de fylder mindre og kører hurtigere, mod en lille, ofte umærkelig, kvalitetsomkostning. Det er grunden til, at en “7b”-model kan fylde under 5 GB i stedet for de 28 GB, den ville fylde i fuld præcision.

Har du en bærbar uden dedikeret GPU og 16 GB RAM, start med qwen2.5-coder:7b eller codegemma:7b. Har du 24 GB VRAM eller mere, kan du gå direkte efter qwen3-coder:30b, som ifølge Ollamas eget bibliotek understøtter op til 256.000 tokens i kontekst, nyttigt når du vil fodre modellen en hel kodefil eller flere filer på én gang. Hent modellen med:

# Hent en mellemstor, alsidig kodemodel
ollama pull qwen2.5-coder:7b

# Eller en større model, hvis du har GPU-kapaciteten til det
ollama pull qwen3-coder:30b

Download-tiden afhænger naturligvis af din internetforbindelse. En 7b-model er typisk 4-5 GB, mens 30b-klassen ligger omkring 19 GB. Når downloadet er færdigt, kan du altid se, hvilke modeller du har liggende lokalt:

Står du mellem DeepSeek-Coder-V2 og Qwen2.5-Coder på nogenlunde samme størrelse, er en praktisk tommelfingerregel at teste begge på dine egne typiske opgaver, frem for at stole blindt på generelle benchmarks. DeepSeek-Coder-V2:16b er interessant, hvis du arbejder med meget lange filer eller flere filer i samme prompt, fordi kontekstvinduet rækker langt uden at kræve en 30b-klasse models hukommelsesforbrug. Codestral er et naturligt valg, hvis dit team allerede bruger andre Mistral-værktøjer og ønsker en konsistent “stemme” i den genererede kode.

ollama list

# Eksempel på output:
# NAME                     ID              SIZE      MODIFIED
# qwen2.5-coder:7b         a1b2c3d4e5f6    4.7 GB    2 minutes ago

Trin 6: Kør din første kodegenerering i terminalen

Nu hvor modellen er hentet, kan du teste den direkte i terminalen, uden nogen ekstra opsætning. Kør:

ollama run qwen2.5-coder:7b

Du lander i en interaktiv prompt, hvor du kan skrive direkte til modellen. Prøv for eksempel:

>>> Skriv en Python-funktion der fjerner dubletter fra en liste uden at ændre den oprindelige rækkefølge

def remove_duplicates(items):
    seen = set()
    result = []
    for item in items:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

Du forlader den interaktive session med /bye eller Ctrl+D. Hastigheden, du oplever her, afgør om modellen reelt er brugbar i din daglige arbejdsgang. Hvis svartiden føles håbløs langsom, er det næsten altid et tegn på, at modellen er for stor til din hardware, og det er værd at skifte til en mindre variant, inden du går videre til API-integrationen.

Trin 7-8: Brug Ollamas REST-API til kodegenerering

Den interaktive terminal er god til at teste en model, men den egentlige værdi kommer, når du kan kalde modellen programmatisk fra dine egne scripts, editorer eller byggepipelines. Ollama eksponerer et REST-API med to centrale endpoints: /api/generate til enkeltstående prompts og /api/chat til samtalebaserede forløb med flere beskeder.

curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5-coder:7b",
  "prompt": "Skriv en funktion i JavaScript der sammenlægger overlappende tidsintervaller",
  "stream": false
}'

Bemærk feltet "stream": false. Ollama streamer svar som standard, token for token, hvilket er fint til en chatgrænseflade, men ofte uhåndterligt i et script der forventer ét samlet JSON-svar. Et typisk svar ser sådan ud:

{
  "model": "qwen2.5-coder:7b",
  "response": "function mergeIntervals(intervals) {\n  ...\n}",
  "done": true
}

Til samtaler med kontekst, hvor modellen skal huske, hvad der blev sagt tidligere, bruger du i stedet /api/chat med en liste af beskeder, inklusive en valgfri systemprompt der sætter rollen:

curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5-coder:7b",
  "messages": [
    { "role": "system", "content": "Du er en præcis kodeassistent, der svarer kort." },
    { "role": "user", "content": "Forklar denne fejl og foreslå en minimal løsning: TypeError: cannot read properties of undefined" }
  ],
  "stream": false
}'

Begge endpoints kan desuden bede om struktureret output via et format-felt med et JSON-schema, hvilket er nyttigt, hvis dit script forventer et fast dataformat i stedet for fritekst. Understøttelsen varierer dog fra model til model, så test altid med den konkrete model, du planlægger at bruge i produktion, før du bygger videre på den.

Forskellen mellem de to endpoints er mere end teknisk bogholderi. /api/generate passer til engangsopgaver, hvor du sender al kontekst i én samlet prompt, for eksempel “forklar denne funktion” eller “skriv en test til denne klasse”. /api/chat passer bedre til værktøjer, der skal føre en løbende dialog, hvor modellen skal huske tidligere spørgsmål i samme session, for eksempel en chatbot i din editor, hvor du stiller opfølgende spørgsmål til det samme stykke kode. Vælger du det forkerte endpoint til opgaven, ender du typisk med at skrive unødigt meget bogholderikode for at simulere den funktionalitet, det andet endpoint allerede giver dig gratis.

Trin 9: Byg din egen tilpassede model med en Modelfile

Når standardmodellen svarer korrekt, men i en tone eller stil der ikke passer dig, kan du lave din egen variant med en Modelfile, uden at træne noget selv. En Modelfile er en simpel tekstfil, der tager udgangspunkt i en eksisterende model og lægger systemprompt, temperatur og andre parametre på toppen.

# Modelfile
FROM qwen2.5-coder:7b

PARAMETER temperature 0.2
PARAMETER num_ctx 16384

SYSTEM """
Du er en erfaren softwareudvikler.
Foretræk små, testbare ændringer.
Returner kørbar kode og forklar vigtige antagelser.
Opfind aldrig API'er, der ikke findes.
"""

Lav derefter din egen navngivne model ud fra filen, og kør den som enhver anden model:

# Byg din tilpassede model
ollama create local-coder -f Modelfile

# Kør den
ollama run local-coder

Den lave temperatur (0.2) gør svarene mere forudsigelige og mindre “kreative”, hvilket typisk er ønskværdigt til kodegenerering, hvor du vil have konsistente, deterministiske svar frem for varierende forslag hver gang. Vil du have mere variation i forslag til navngivning eller arkitektur, kan du skrue temperaturen op mod 0.7-0.9 i en separat Modelfile til det formål.

Trin 10: Integrer Ollama med VS Code via Continue

Den mest praktiske brug af en lokal kodemodel er inline-forslag direkte i editoren, og her er Continue en af de mest brugte broer til Ollama. Continue er open source under Apache 2.0-licens og kører helt lokalt, uden at kontakte nogen server, selv efter at den hostede Hub-tjeneste blev lukket i juli 2026 i forbindelse med, at Cursor-udvikleren Anysphere overtog teamet bag projektet. Udvidelsen selv fungerer upåvirket af det, fordi den aldrig har krævet en cloud-afhængighed for at tale med en lokal model som Ollama.

Installer Continue fra VS Code’s Extensions-panel (søg efter “Continue”), og rediger derefter konfigurationsfilen, som typisk ligger under ~/.continue/config.yaml:

name: Lokal Ollama-kodning
version: 0.0.1
schema: v1

models:
  - name: Qwen2.5 Coder 7B
    provider: ollama
    model: qwen2.5-coder:7b
    apiBase: http://localhost:11434

  - name: CodeGemma Autocomplete
    provider: ollama
    model: codegemma:7b
    apiBase: http://localhost:11434
    roles:
      - autocomplete

Bemærk, at vi har tildelt en separat, lettere model til rollen autocomplete. Inline-forslag skal komme hurtigt, mens du skriver, så en stor chat-model ofte er for langsom til formålet. Brug derfor gerne en mindre model til løbende forslag, og gem den større model til chat-baserede spørgsmål og større refaktoreringer.

Genstart VS Code efter ændringen, og tjek at forbindelsen virker, før du begynder at stole på forslagene i en rigtig kodebase:

curl http://localhost:11434/api/tags

Fejler denne kommando, vil Continue heller ikke kunne forbinde, uanset hvordan konfigurationsfilen ser ud. Se mere om Continues konfigurationsformat i den officielle Continue-dokumentation.

Trin 11: Aktiver GPU-acceleration (CUDA, ROCm og Metal)

Ollama forsøger automatisk at bruge din GPU, hvis den finder en kompatibel driver, men det er værd at bekræfte, at accelerationen faktisk er aktiv, især hvis svartiderne føles langsommere end forventet.

Har du en Nvidia-GPU, skal du have en opdateret driver installeret. Bekræft at GPU’en er synlig for systemet, og at Ollama kan finde CUDA:

# Tjek at Nvidia-driveren og GPU'en er synlige
nvidia-smi

Se den officielle Nvidia CUDA-dokumentation, hvis nvidia-smi ikke virker, eller hvis du er i tvivl om, hvilken driverversion din GPU kræver. Ollama bruger CUDA automatisk, når driveren er på plads. Der er typisk intet ekstra at konfigurere i Ollama selv.

På AMD-GPU’er under Linux skal ROCm være installeret og din GPU-model understøttet. Tjek status med:

# Tjek ROCm og AMD-GPU'en
rocminfo

Ikke alle AMD-kort er understøttet af alle ROCm-versioner, så tjek kompatibilitetslisten i AMDs ROCm-dokumentation, før du fejlsøger videre i Ollama selv.

Har du en Mac med Apple Silicon, bruges Metal-acceleration automatisk uden ekstra konfiguration, via Apples Metal-API. Her er den vigtige detalje unified memory: CPU og GPU deler den samme hukommelsespulje, så en Mac med 16 GB samlet hukommelse har mindre reel kapacitet til en stor model, end tallet 16 GB umiddelbart antyder, fordi styresystemet og andre programmer også skal bruge af den samme pulje.

En praktisk konsekvens af unified memory er, at du bør lukke tunge applikationer som browservinduer med mange faneblade eller andre AI-værktøjer, før du tester en stor model på en Mac. Modsat en dedikeret GPU med egen VRAM, hvor andre programmer ikke konkurrerer om den samme hukommelse, mærker du på en Mac direkte, hvis resten af systemet også lægger beslag på den samme pulje, modellen forsøger at bruge.

Trin 12-13: Byg et komplet projekt, en lokal commit-besked-assistent

Nu samler vi det, du har lært, i et færdigt, brugbart projekt: et lille script, der læser dine stagede Git-ændringer og bruger din lokale model til at skrive et forslag til en commit-besked. Det er et realistisk eksempel på, hvordan kodegenerering bruges i praksis, uden at sende en linje kode uden for din maskine.

Opret en fil kaldet ai-commit.sh i et vilkårligt Git-repository:

#!/usr/bin/env bash
# ai-commit.sh - genererer en commit-besked ud fra stagede ændringer via lokal Ollama

DIFF=$(git diff --staged)

if [ -z "$DIFF" ]; then
  echo "Ingen stagede ændringer. Kør 'git add' først."
  exit 1
fi

PROMPT=$(cat <

chmod +x ai-commit.sh
git add .
./ai-commit.sh

# Eksempel på output:
# Ret null-tjek i login-funktionen og tilføj fejlbesked

# Se installerede modeller og deres størrelse
ollama list

# Fjern en model, du ikke bruger længere
ollama rm starcoder2:15b

# Se hvilke modeller der aktuelt er indlæst i hukommelsen
ollama ps

# Start Ollama i en container med persistent lagring af modeller
docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

# Hent en model inde i containeren
docker exec -it ollama ollama pull qwen2.5-coder:7b

# Test API'et udefra, som hvis Ollama kørte native
curl http://localhost:11434/api/tags