llama.cpp Snabbstart med CLI och Server

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

Om du fortfarande är i färd med att välja mellan lokala, självvärdiga och molnbaserade lösningar, börja med guideen LLM Hosting i 2026: Lokal, självvärd och molninfrastruktur jämförd.

Varför llama.cpp i 2026

llama.cpp är en lättviktig inferensmotor med en förskjutning mot:

• portabilitet över CPU:er och flera GPU-arkitekturer,
• förutsägbar latens på en enda dator,
• distributionsskikt, från datorer till on-prem noder.

Det lyser när du vill ha säkerhet och offline-drift, när du behöver bestämd kontroll över körningsflaggor eller när du vill bädda in inferens i ett större system utan att köra en fullständig Python-baserad stack.

Det är också användbart att förstå llama.cpp även om du senare väljer en högre genomströmningsserverkörning. Till exempel, om din mål är maximal servergenomströmning på GPU:er, kan du också vilja jämföra det med vLLM med hjälp av: vLLM Quickstart: Högpresterande LLM Server och du kan testa verktygsväljare i: Ollama vs vLLM vs LM Studio: Bästa sättet att köra LLM:er lokalt i 2026?.

Installera llama.cpp på Windows, macOS och Linux

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

Installera via pakethanterare

Detta är snabbaste alternativet för att “starta”.

# 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, bekräfta att verktygen finns:

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

Installera via förutfärdade binärer

Om du vill ha en ren installation utan kompilerare, använd de officiella förutfärdade binärerna som publicerats i llama.cpp GitHub-releases. De täcker vanligtvis flera OS-mål och flera bakändar (endast CPU och GPU-aktiverade versioner).

En vanlig arbetsflöde:

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

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

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

Om du bryr dig om att få ut den bästa prestandan ur din CPU/GPU-bakända, bygg 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 bygge finns binärerna vanligtvis här:

ls -la ./build/bin/

GPU-bygg i ett kommando

Aktivera den bakända 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: fullt bygg genomgång

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

1. Installera CUDA-verktygssatsen 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 verktygssats
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-utvecklingshuvudfiler (krävs för ren bygg):

sudo apt update
sudo apt install libssl-dev

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

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
cp llama.cpp/build/bin/llama-* llama.cpp

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

Du kan också kompilera flera bakändor och välja enheter vid körning. Detta är användbart om du distribuerar 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 en enkel filformat som paketerar modellviktigheter 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 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

Modern llama.cpp-bygg kan ladda ner från Hugging Face och behålla filer i en lokal cache. Detta är ofta den 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 på en tid," \
  -n 200

Du kan också specifiera kvantiseringen i repo-urval 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 paragraf." \
  -n 160

Om du behöver ett fullständigt offline-arbetsflöde senare, tvingar --offline cacheanvändning och förhindrar nätverksåtkomst.

Kvantisering val för lokal inferens

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

En praktisk startpunkt:

• börja med en Q4 eller Q5 variant för CPU-först maskiner,
• flytta till högre precision (eller mindre aggressiv kvantisering) när du kan ta upp minnet 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 samplingssjusteringar.

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 viktiga parametrar

llama-cli är den snabbaste sättet att bekräfta att din modell laddas, din bakända fungerar och dina prompter 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 chatkörning

Konversationsläge är utformat för chatmallar. Det aktiverar vanligtvis interaktiv beteende och formaterar prompter 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 spelar roll

Snarare än att lära sig 200 flaggor, fokusera på de som dominerar rättigheter, latens och minne.

Modell och nedladdning

Kontext och genomströmning

GPU-avlastning och hårdvaruväljare

Sampling och utgångskvalitet

Exempelarbetsbelastningar med llama-cli

Sammanfatta en fil, inte bara en prompt

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

Gör resultat mer återvinnbara

När du felsöker prompter, fixa sätet och minska slumpen:

llama-cli \
  -m models/my-model.gguf \
  -p "Extrahera nyckelrisker från detta designdokument." \
  -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 slutpunkter för chat, kompletteringar, inbäddningar och svar,
• en webbgränssnitt för interaktiv testning,
• valfria övervaknings slutpunkter för produktionssynlighet.

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 utifrån (t.ex. inuti Docker eller LAN), specifiera värd 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 behållare kan många inställningar också kontrolleras via LLAMA_ARG_* miljövariabler.

Exempel på API-anrop

Chatkompletteringar 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 checklist." }
    ],
    "temperature": 0.7
  }'

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

OpenAI Python-klient som riktar sig till llama-server

Med en OpenAI-kompatibel server kan många klienter fungera genom att ändra endast 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

OpenAI-kompatibla inbäddningar exponeras vid /v1/embeddings, men modellen måste stödja en 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ärld"],
    "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/my-embedding-model.gguf \
  --embeddings \
  --host 127.0.0.1 \
  --port 8080

Prestanda, övervakning och produktionssäkring

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

• Minnesgränsen är vanligtvis den första begränsningen (RAM på CPU, VRAM på GPU).
• Kontextstorleken är en viktig minnesmultiplikator.
• GPU-lageravlastning är ofta den snabbaste vägen till fler token per sekund.
• Batchstorlekar och trådar kan förbättra genomströmning men kan också öka minnespress.

För en djupare, teknikförst sikt, se: LLM Prestanda i 2026: Benchmarkar, fläckar & optimering.

Övervaka llama-server med Prometheus och Grafana

llama-server kan exponera Prometheus-kompatibla metriker vid /metrics när --metrics är aktiverad. Detta passar naturligt med Prometheus skrapkonfigurationer och Grafana-dashboards.

För dashboards och varningar specifikt för llama.cpp (och vLLM, TGI): Övervaka LLM-inferens i produktion (2026): Prometheus & Grafana för vLLM, TGI, llama.cpp. Mer allmänna guider: Övervakning: Övervakning, metriker, Prometheus & Grafana-guide och Övervakning för LLM-system.

Grundläggande säkringschecklista

När din llama-server är tillgänglig utanför localhost:

• använd --api-key (eller --api-key-file) så att begäranden autentiseras,
• undvik att binda till 0.0.0.0 om du inte behöver det,
• överväg TLS via servers 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 för felsökning

Modellen laddas men svaren är konstiga i chatt

Chat-slutpunkter fungerar bäst när modellen har en stödd chatmall. Om utdata verkar ostrukturerade, prova:

• använda llama-cli --conversation plus en explicit --system-prompt,
• bekräfta att din modell är en instruktions- eller chat-justerad variant,
• testa med serverns webbgränssnitt innan du ansluter den till ett program.

Du träffar minnesproblem

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,
• moderata batchstorlekar,
• bekräfta att du installerade en bygg som matchar din dator (CPU-funktioner och bakända).

Referenser

• Officiell llama.cpp-repo och dokumentation
• Officiell CLI-flaggor dokumentation
• Officiell llama-server dokumentation och API-detaler