Snabbstart för llama.cpp med CLI och server

Jag återkommer gång på gång till llama.cpp för lokal inferens – det ger dig kontroll som Ollama och andra abstraherar bort, och det fungerar bara enkelt. Det är lätt att köra GGUF-modeller interaktivt med llama-cli eller exponera ett OpenAI-kompatibelt HTTP-API med llama-server.

Om du fortfarande funderar på lokala, självhostade och molnbaserade lösningar, börja med den grundläggande guiden LLM-hostning 2026: Lokalt, självhostat och molninfrastruktur jämfört.

Varför llama.cpp 2026

llama.cpp är en lättviktig inferensemotor med en tydlighet för:

• portabilitet över CPU:er och flera GPU-backendar,
• förutsägbar latens på en enda maskin,
• flexibel distribution, från bärbara datorer till on-prem-noder.

Den lyser när du vill ha integritet och offline-drift, när du behöver deterministisk kontroll över runtime-flaggor, eller när du vill infoga inferens i ett större system utan att köra en tung Python-stack.

Det är också hjälpsamt att förstå llama.cpp även om du senare väljer en serverruntime med högre genomströmning. Till exempel, om ditt mål är maximal serveringströmning på GPU:er, kan du också vilja jämföra den med vLLM med hjälp av: vLLM Quickstart: Högpresterande LLM-servering och du kan benchmarka verktygsval i: Ollama vs vLLM vs LM Studio: Bäst sätt att köra LLM:er lokalt 2026?.

Installera llama.cpp på Windows, macOS och Linux

Det finns tre praktiska installationsvägar, beroende på om du vill ha bekvämlighet, portabilitet eller maximal prestanda.

Installera via pakethanterare

Detta är det snabbaste alternativet för att “komma igång”.

# macOS eller Linux
brew install llama.cpp

# Windows
winget install llama.cpp

# macOS (MacPorts)
sudo port install llama.cpp

# macOS eller Linux (Nix)
nix profile install nixpkgs#llama-cpp

Tips: Efter installationen, verifiera att verktygen finns:

llama-cli --version
llama-server --version

Installera via färdiga binärer

Om du vill ha en ren installation utan kompilatorer, använd de officiella färdiga binärerna som publicerats i llama.cpp GitHub-releases. De täcker typiskt flera OS-mål och flera backendar (varianten för endast CPU och GPU-aktiverade varianter).

En vanlig arbetsflödesprocess:

# 1) Ladda ner rätt arkiv för ditt OS och din backend
# 2) Packa upp det
# 3) Kör från den packade mappen

./llama-cli --help
./llama-server --help

Kompilera från källkoden för din exakta hårdvara

Om du bryr dig om att få ut bästa prestanda från din CPU/GPU-backend, kompilera från källkoden med CMake.

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

# CPU-bygg
cmake -B build
cmake --build build --config Release

Efter bygget finns binärerna typiskt här:

ls -la ./build/bin/

GPU-bygg i ett kommando

Aktivera backenden som matchar din hårdvara (exemplen visar CUDA och Vulkan):

# NVIDIA CUDA
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

# Vulkan
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release

Ubuntu 24.04 + NVIDIA GPU: komplett byggnationsgenomgång

På Ubuntu 24.04 med en NVIDIA GPU behöver du CUDA-toolkitet och OpenSSL innan du bygger. Här är en testad sekvens:

1. Installera CUDA-toolkit 13.1

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin
sudo mv cuda-ubuntu2404.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/13.1.1/local_installers/cuda-repo-ubuntu2404-13-1-local_13.1.1-590.48.01-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2404-13-1-local_13.1.1-590.48.01-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2404-13-1-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-13-1

2. Lägg till CUDA i din miljö (lägg till i ~/.bashrc):

# cuda toolkit
export PATH=/usr/local/cuda-13.1/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-13.1/lib64:$LD_LIBRARY_PATH

Kör sedan source ~/.bashrc eller öppna en ny terminal.

3. Installera OpenSSL-utvecklingshuvuden (krävs för ett rent bygge):

sudo apt update
sudo apt install libssl-dev

4. Bygg llama.cpp (från mappen som innehåller din llama.cpp-klon, med CUDA aktiverat):

cmake llama.cpp -B llama.cpp/build -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split llama-embedding
cp llama.cpp/build/bin/llama-* llama.cpp

Detta producerar llama-cli, llama-mtmd-cli, llama-server, llama-embedding och llama-gguf-split i llama.cpp-mappen.

Du kan också kompilera flera backendar och välja enheter vid runtime. Detta är användbart om du distribuerar samma bygge på heterogena maskiner.

Välj en GGUF-modell och en kvantisering

För att köra inferens behöver du en GGUF-modellfil (*.gguf). GGUF är ett en-fil-format som buntar ihop modellviktningar plus standardiserad metadata som krävs av motorer som llama.cpp.

Två sätt att få en modell

Alternativ A: Använd en lokal GGUF-fil

Ladda ner eller kopiera en GGUF till ./models/:

mkdir -p models
# Placera din GGUF i models/my-model.gguf

Kör den sedan via sökväg:

llama-cli -m models/my-model.gguf -p "Hej! Förklara vad llama.cpp är." -n 128

Alternativ B: Låt llama.cpp ladda ner från Hugging Face

Moderna llama.cpp-byggen kan ladda ner från Hugging Face och behålla filer i en lokal cache. Detta är ofta det lättaste arbetsflödet för snabba experiment.

# Ladda ner en modell från HF och kör en prompt
llama-cli \
  --hf-repo ggml-org/tiny-llamas \
  --hf-file stories15M-q4_0.gguf \
  -p "En gång i tiden," \
  -n 200

Du kan också specificera kvantiseringen i repo-väljaren och låta verktyget välja en matchande fil:

llama-cli \
  --hf-repo unsloth/phi-4-GGUF:q4_k_m \
  -p "Sammanfatta konceptet med kvantisering i en mening." \
  -n 160

Om du behöver ett helt offline-arbetsflöde senare, tvingar --offline cache-användning och förhindrar nätverksåtkomst.

Val av kvantisering för lokal inferens

Kvantisering är det praktiska svaret på frågan “Vilken GGUF-kvantisering ska du välja för lokal inferens” eftersom den direkt avväger kvalitet, modellstorlek och hastighet.

En pragmatisk startpunkt:

• börja med en Q4- eller Q5-variant för CPU-första-maskiner,
• gå över till högre precision (eller mindre aggressiv kvantisering) när du har råd med RAM eller VRAM,
• när modellen “känns dum” för din uppgift, är lösningen ofta antingen en bättre modell eller en mindre aggressiv kvant, inte bara justeringar av sampling.

Kom också ihåg att kontextfönstret spelar roll: större kontextstorlekar ökar minnesanvändningen (ibland dramatiskt), även när GGUF-filen själv passar.

llama-cli quickstart och nyckelparametrar

llama-cli är det snabbaste sättet att validera att din modell laddas, att din backend fungerar och att dina prompts beter sig som förväntat.

Minimal körning

llama-cli \
  -m models/my-model.gguf \
  -p "Skriv en kort jämförelse mellan TCP och UDP." \
  -n 200

Interaktiv chattkörning

Konversationsläget är designat för chattmallar. Det aktiverar vanligtvis interaktivt beteende och formaterar prompts enligt modellens mall.

llama-cli \
  -m models/my-model.gguf \
  --conversation \
  --system-prompt "Du är en koncis systemingenjörsassistent." \
  --ctx-size 4096

För att avsluta generationen när modellen skriver ut en specifik sekvens, använd en reverse prompt. Detta är särskilt användbart i interaktivt läge.

Huvudflaggor för llama-cli som spelar roll

Istället för att memorera 200 flaggor, fokusera på de som dominerar korrekthet, latens och minne.

Modell och nedladdning

Kontext och genomströmning

GPU-offload och hårdvaruval

Sampling och utmatningskvalitet

Exempel på arbetsbelastningar med llama-cli

Sammanfatta en fil, inte bara en prompt

llama-cli \
  -m models/my-model.gguf \
  --system-prompt "Du sammanfattar tekniska dokument. Utmatning max fem punkter." \
  --file ./docs/incident-report.txt \
  -n 300

Gör resultaten mer reproducerbara

När du felsöker prompts, fixera seedet och minska slumpmässigheten:

llama-cli \
  -m models/my-model.gguf \
  -p "Extrahera nyckelrisker från denna designanteckning." \
  -n 200 \
  --seed 42 \
  --temp 0.2

llama-server quickstart med OpenAI-kompatibelt API

llama-server är en inbyggd HTTP-server som kan exponera:

• OpenAI-kompatibla ändpunkter för chatt, kompletteringar, inbäddningar (embeddings) och svar,
• ett webbgränssnitt för interaktiv testning,
• valfria övervakningsändpunkter för produktionsinsyn.

Starta en server med en lokal modell

llama-server \
  -m models/my-model.gguf \
  -c 4096

Som standard lyssnar den på 127.0.0.1:8080.

För att binda externt (till exempel inuti Docker eller ett LAN), specificera host och port:

llama-server \
  -m models/my-model.gguf \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080

Valfria men viktiga serverflaggor

Om du kör i containrar kan många inställningar också kontrolleras genom LLAMA_ARG_*-miljövariabler.

Exempel på API-anrop

Chattkompletteringar med curl

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      { "role": "system", "content": "Du är en hjälpsam assistent." },
      { "role": "user", "content": "Ge mig en snabb checklista för llama.cpp." }
    ],
    "temperature": 0.7
  }'

Tips för riktiga distributioner: om du anger --api-key, kan du skicka den via en x-api-key-header (eller fortsätta använda Authorization-headers beroende på din gateway).

OpenAI Python-klient som riktar sig mot llama-server

Med en OpenAI-kompatibel server kan många klienter fungera genom att endast ändra base_url.

import openai

client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="sk-no-key-required",
)

resp = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "Du är en koncis assistent."},
        {"role": "user", "content": "Förklara trådar vs batchstorlek i llama.cpp."},
    ],
)

print(resp.choices[0].message.content)

Inbäddningar (Embeddings)

OpenAI-kompatibla inbäddningar exponeras på /v1/embeddings, men modellen måste stödja ett inbäddningspoolingläge som inte är none.

curl http://localhost:8080/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "input": ["hello", "world"],
    "model": "GPT-4",
    "encoding_format": "float"
  }'

Om du kör en dedikerad inbäddningsmodell, överväg att starta servern i inbäddningsenbart-läge:

llama-server \
  -m models/Qwen3-Embedding-0.6B-Q8_0.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --pooling last \
  --port 8080

eller om du vill köra llama-cpp med inbäddningsmodell på CPU:

CUDA_VISIBLE_DEVICES="" llama-server \
  -m models/Qwen3-Embedding-0.6B-Q8_0.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --pooling last \
  --port 8080

prova det så här:

CUDA_VISIBLE_DEVICES="" llama-embedding \
  -m /path/to/Qwen3-Embedding-0.6B-Q8_0.gguf \
  -p "din text här" \
  --pooling last \
  --verbose-prompt

Servera flera modeller från en process

Exemplen ovan binder llama-server till en enda modell vid start. Om du behöver växla mellan modeller per begäran – utan att starta om processen – är det det routerläget är för. Se llama-server routerläge: dynamisk modellväxling utan omstart. För ett skriptbart flöde för att avlasta alla modeller som frigör VRAM utan att starta om routern, se Avlasta alla llama.cpp-routermodeller utan omstart.

Prestanda, övervakning och produktionsförstärkning

FAQ-frågan “Vilka llama.cpp-kommandoradsalternativ spelar störst roll för hastighet och minne” blir mycket lättare när du behandlar inferens som ett system:

• Minnesgränsen är vanligtvis den första begränsningen (RAM på CPU, VRAM på GPU).
• Kontextstorlek är en stor minnesmultiplikator.
• GPU-lageroffload är ofta den snabbaste vägen till högre tokens per sekund.
• Batchstorlekar och trådar kan förbättra genomströmningen men kan också öka minnespressen.

För en djupare, engineering-först-perspektiv, se: LLM-prestanda 2026: Benchmarks, flaskhalsar & optimering.

Om du vill ha mätta llama-cli-liknande resultat på en GPU i 16 GB-klassen – tokens per sekund, VRAM och GPU-belastning medan du sveper kontext (19K / 32K / 64K) över täta och MoE GGUF:er – se 16 GB VRAM LLM-benchmarks med llama.cpp (hastighet och kontext).

För Qwen 3.6 specifikt, stöder llama.cpp nu inbyggd Multi-Token Prediction (MTP) spekulativ dekodering som kan öka generationsgenomströmningen avsevärt. Se Qwen 3.6 27B och 35B MTP vs Standard på 16GB GPU för mätta generationshastigheter, VRAM-överhead och rekommenderade --spec-draft-n-max-värden.

Övervaka llama-server med Prometheus och Grafana

llama-server kan exponera Prometheus-kompatibla mätningar på /metrics när --metrics är aktiverat. Detta par naturligt med Prometheus scrape-konfigurationer och Grafana-dashboarder.

För dashboarder och alarmer specifikt för llama.cpp (och vLLM, TGI): Övervaka LLM-inferens i produktion (2026): Prometheus & Grafana för vLLM, TGI, llama.cpp. Bredare guider: Observability: Övervakning, Mätningar, Prometheus & Grafana Guide och Observability för LLM-system.

Grundläggande checklist för förstärkning

När din llama-server är nåbar utöver localhost:

• använd --api-key (eller --api-key-file) så att begäranden är autentiserade,
• undvik att binda till 0.0.0.0 om du inte behöver det,
• överväg TLS via serverns SSL-flaggor eller avsluta TLS vid en reverse proxy,
• begränsa samtidighet med --parallel för att skydda latensen under last.

Snabba lösningar för felsökning

Modellen laddas men svaren är märkliga i chatt

Chattändpunkter är bäst när modellen har en chattmall som stöds. Om utmatningen ser ostrukturerad ut, prova:

• att använda llama-cli --conversation plus en explicit --system-prompt,
• att verifiera att din modell är en instruktion- eller chatt-tuned variant,
• att testa med serverns webbgränssnitt innan du kopplar in den i en app.

Du får out of memory (minnesbrist)

Minska kontexten eller välj en mindre kvant:

• sänk --ctx-size,
• minska --n-gpu-layers om VRAM är problemet,
• byt till en mindre modell eller en mer komprimerad kvant.

Det är långsamt på CPU

Börja med:

• --threads lika med dina fysiska kärnor,
• måttliga batchstorlekar,
• att validera att du installerat ett bygge som matchar din maskin (CPU-funktioner och backend).

Referenser

• Officiellt llama.cpp-arkiv och dokumentation
• Officiell dokumentation för CLI-flaggor
• Officiell dokumentation för llama-server och API-detajler