llama.cpp: Snabbstart med CLI och server

Jag återvänder alltid till llama.cpp för lokal inferens – det ger dig kontroll som Ollama och andra abstraherar bort, och det fungerar helt enkelt. Det är enkelt att köra GGUF-modeller interaktivt med llama-cli eller exponera en OpenAI-kompatibel HTTP-API med llama-server.

Om du fortfarande bestämmer dig mellan lokala, självhysta och moln-baserade lösningar, börja med guidepelaren LLM-värdskap 2026: Lokal, självhyst och molninfrastruktur jämfört.

Varför llama.cpp 2026

llama.cpp är en lättviktig inferensmotor med en benägenhet för:

• portabilitet över CPU:er och flera GPU-bakomliggande system,
• förutsägbar latens på en enda maskin,
• flexibilitet i deployement, från bärbara datorer till lokala noder.

Det skiner när du vill ha integritet och offline-funktion, när du behöver deterministisk kontroll över körningsflaggor, eller när du vill bädda in inferens i ett större system utan att köra en full Python-tung stack.

Det är också bra att förstå llama.cpp även om du senare väljer en serverkörning med högre genomströmning. Till exempel, om ditt mål är maximal servergenomströmning på GPU:er, kanske du också vill jämföra det med vLLM med hjälp av: vLLM Snabbstart: Högpresterande LLM-värdskap och du kan benchmarka verktygsval i: Ollama vs vLLM vs LM Studio: Bäst sätt att köra LLM 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 förvaltningsprogram

Detta är det snabbaste alternativet för att “få det 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 installation, 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ärena som publiceras i llama.cpp GitHub-releases. De täcker vanligtvis flera operativsystem och flera backend-system (CPU-endast och GPU-aktiverade varianter).

En vanlig arbetsflödes:

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

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

Bygg från källkod för din exakta hårdvara

Om du bryr dig om att pressa ut bästa prestanda från din CPU/GPU-backend, bygg från källkod 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ärena vanligtvis här:

ls -la ./build/bin/

GPU-bygg i ett kommando

Aktivera backend som matchar din hårdvara (exempel visas för 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: full bygggenomgång

På Ubuntu 24.04 med en NVIDIA GPU behöver du CUDA-toolkiten 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ö (appender till ~/.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-utvecklingsrubriker (krävs för ett rent bygg):

sudo apt update
sudo apt install libssl-dev

4. Bygg llama.cpp (från mappen som innehåller din llama.cpp-kloning, 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 backend-system och välja enheter vid körning. Detta är användbart om du deployar samma bygg till 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 filformat som sammanfattar modellvikt plus standardiserad metadata som motorer som llama.cpp behöver.

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 på models/my-model.gguf

Kör sedan den 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

Moderne llama.cpp-bygg kan ladda ner från Hugging Face och hålla filer i en lokal cache. Detta är ofta det enklaste 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 reposvalaren och låta verktyget välja en matchande fil:

llama-cli \
  --hf-repo unsloth/phi-4-GGUF:q4_k_m \
  -p "Sammanfatta konceptet kvantisering i en styck." \
  -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 bör du välja för lokal inferens” eftersom det 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 kan tillåta dig 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 kvantisering, inte bara sampling-tweaks.

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

llama-cli snabbstart 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 rätt.

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äge ä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 generering när modellen skriver en specifik sekvens, använd en omvänd prompt. Detta är särskilt användbart i interaktivt läge.

Huvudsakliga llama-cli-flaggor som betyder något

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 outputkvalitet

Exempel på arbetsflöden med llama-cli

Sammanfatta en fil, inte bara en prompt

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

Gör resultat mer reproducerbara

När du felsöker prompts, fixa seed och minska slumpmässighet:

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

llama-server snabbstart med OpenAI-kompatibel API

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

• OpenAI-kompatibla ändpunkter för chatt, kompletteringar, inbäddningar och svar,
• ett webbgränssnitt för interaktiv testning,
• valbara ö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 värd och port:

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

Valbara men viktiga serverflaggor

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

Exempel på API-begäran

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 llama.cpp-kontrolllista." }
    ],
    "temperature": 0.7
  }'

Tips för riktiga deployement: om du sätter --api-key, kan du skicka den via en x-api-key-rubrik (eller fortsätta använda Authorization-rubriker beroende på din gateway).

OpenAI Python-klient som riktar mot llama-server

Med en OpenAI-kompatibel server kan många klienter fungera genom att bara ä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 mot batchstorlek i llama.cpp."},
    ],
)

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

Inbäddningar

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

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

Om du kör en dedikerad inbäddningsmodell, överväg att starta servern i endast inbäddningslä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 byta mellan modeller per begäran – utan att starta om processen – det är vad routarläget är för. Se llama-server routarläge: dynamiskt modellbytte utan omstart.

Prestanda, övervakning och produktionshärdning

FAQ-frågan “Vilka llama.cpp-kommandoradsoptioner betyder mest för hastighet och minne” blir mycket enklare när du behandlar inferens som ett system:

• Minnesgolv ä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 token per sekund.
• Batch-storlekar och trådar kan förbättra genomströmning men kan också öka minnespress.

För en djupare, ingenjörsmässig syn, se: LLM-prestanda 2026: Benchmark, flaskhalsar & optimering.

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

Övervaka llama-server med Prometheus och Grafana

llama-server kan exponera Prometheus-kompatibla mätvärden på /metrics när --metrics är aktiverat. Detta parar naturligt med Prometheus scrape-konfigurationer och Grafana-tavlor.

För tavlor och varningar specifika 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ätvärden, Prometheus & Grafana-guide och Observability för LLM-system.

Grundläggande härdningskontrolllista

När din llama-server är nåbar bortom localhost:

• använd --api-key (eller --api-key-file) så att begäran autentiseras,
• 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 omvänd proxy,
• begränsa samtidighet med --parallel för att skydda latens under belastning.

Snabba lösningar på felsökning

Modellen laddas men svaren är konstiga i chatt

Chattändpunkter är bäst när modellen har ett stött chattmall. Om utdata ser ostrukturerad ut, prova:

• använd llama-cli --conversation plus en explicit --system-prompt,
• verifiera att din modell är en instruktions- eller chattjusterad variant,
• testa med serverns webbgränssnitt innan du kopplar det till en app.

Du träffar minnesbrist

Minska kontexten eller välj en mindre kvantisering:

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

Det är långsamt på CPU

Börja med:

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

Referenser

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