Lokale LLMs

Durch die lokale Ausführung großer Sprachmodelle (LLMs) wird der Datenschutz geschützt, die API-Kosten gesenkt und Offline-Inferenzfunktionen bereitgestellt. Ubuntu 26.04 bietet eine hervorragende Umgebung zum Ausführen lokaler LLMs. In diesem Artikel werden die beliebtesten lokalen Modelllaufzeittools und empfohlenen Modelle behandelt.

Tip

Möchten Sie eine dedizierte „KI-Box“-Appliance erstellen, anstatt sie auf Ihrem Desktop auszuführen? Im Juni 2026 veröffentlichte Canonical eine offizielle Referenz, die auf Ubuntu Core 26 + dem gemma4-Snap basiert und eine OpenAI-kompatible API (:8336/v1) und eine WebUI (:8337) offenlegt. Der minimale Bootstrap ist in den Post-Release-News dokumentiert.

Ollama

Ollama ist derzeit das beliebteste Laufzeit-Framework für lokale Modelle und bietet eine äußerst einfache Installation und Nutzung sowie Unterstützung für eine breite Palette von Open-Source-Modellen.

Installieren Sie Ollama


# One-click installation (recommended)
curl -fsSL https://ollama.com/install.sh | bash
 
# Verify installation
ollama --version
 
# Check Ollama service status
systemctl status ollama


# Manual installation (if the auto script doesn't work)
# Download and extract the official tgz package to /usr
curl -L https://ollama.com/download/ollama-linux-amd64.tgz -o /tmp/ollama-linux-amd64.tgz
sudo tar -C /usr -xzf /tmp/ollama-linux-amd64.tgz
 
# Create Ollama user
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama
 
# Create systemd service (use sudo tee to write a root-owned file)
sudo tee /etc/systemd/system/ollama.service > /dev/null << 'EOF'
[Unit]
Description=Ollama Service
After=network-online.target
 
[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="HOME=/usr/share/ollama"
 
[Install]
WantedBy=default.target
EOF
 
sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama

Pull-and-Run-Modelle


# Pull a model (downloads the model file on first run)
ollama pull llama3.2
ollama pull qwen2.5:14b
ollama pull deepseek-r1:14b
 
# Run a model and start chatting
ollama run llama3.2
 
# Run a specific model size
ollama run qwen2.5:7b
ollama run qwen2.5:14b
ollama run qwen2.5:32b
 
# List downloaded models
ollama list
 
# View model details
ollama show qwen2.5:14b
 
# Delete a model
ollama rm llama3.2

API-Nutzung

Ollama stellt eine mit dem OpenAI-Format kompatible REST-API bereit, die standardmäßig auf http://localhost:11434 lauscht.


# Generate text (Generate API)
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5:14b",
  "prompt": "Explain Python decorators",
  "stream": false
}'
 
# Chat API (conversational format)
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:14b",
  "messages": [
    {"role": "system", "content": "You are a Linux expert"},
    {"role": "user", "content": "How do I check the Ubuntu system version?"}
  ],
  "stream": false
}'
 
# OpenAI-compatible API
curl http://localhost:11434/v1/chat/completions -d '{
  "model": "qwen2.5:14b",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}'
 
# List available models
curl http://localhost:11434/api/tags

Python Anwendungsbeispiel


# Ubuntu 26.04 blocks system-wide pip installs (PEP 668); install inside a virtual environment
python3 -m venv ~/ollama-env
source ~/ollama-env/bin/activate
 
# Install the ollama Python library
pip install ollama


import ollama
 
response = ollama.chat(model='qwen2.5:14b', messages=[
    {'role': 'user', 'content': 'Write a quicksort algorithm in Python'},
])
print(response['message']['content'])

Konfigurieren Sie Ollama


# Change model storage path (default: ~/.ollama/models)
sudo systemctl edit ollama
# Add the following:
# [Service]
# Environment="OLLAMA_MODELS=/data/ollama/models"
 
# Allow remote access (default is local only)
sudo systemctl edit ollama
# [Service]
# Environment="OLLAMA_HOST=0.0.0.0:11434"
 
# Set GPU layers
# Environment="OLLAMA_NUM_GPU=999"
 
# Restart service to apply changes
sudo systemctl restart ollama

Empfohlene Modelle

Modell	Parameter	VRAM erforderlich	Höhepunkte
`qwen2.5:7b`	7B	6 GB	Starke Chinesischkenntnisse, gut für den täglichen Chat
`qwen2.5:14b`	14B	10 GB	Umfassendes Chinesisch, gute Programmierung
`qwen2.5-coder:7b`	7B	6 GB	Konzentriert sich auf Codegenerierung und -verständnis
`llama3.2:3b`	3B	3 GB	Leicht, schnell
`llama3.1:8b`	8B	6 GB	Ausgezeichnete Englischkenntnisse
`deepseek-r1:14b`	14B	10 GB	Starke Argumentation
`mistral:7b`	7B	6 GB	Europäisches Modell, mehrsprachig
`gemma2:9b`	9B	7 GB	Open-Source-Modell von Google
`phi3:14b`	14B	10 GB	Microsoft-Forschungsmodell
`nomic-embed-text`	-	1 GB	Texteinbettungsmodell

Tip

Für Benutzer der chinesischen Sprache wird die Qwen 2.5-Serie dringend empfohlen. Die 7B-Version eignet sich für GPUs mit 8 GB VRAM, während die 14B-Version mit 12 GB VRAM eine hervorragende Leistung erbringt. Für Nur-Code-Aufgaben ist qwen2.5-coder die beste Wahl.

LM Studio

LM Studio ist ein plattformübergreifendes grafisches lokales Modellverwaltungstool, das das Herunterladen von Modellen, Chat und einen lokalen API-Server bietet.

Herunterladen und installieren


# Download LM Studio AppImage from the official site (get the latest link at https://lmstudio.ai/download)
# Replace the URL below with the actual download link from the official site
wget -O ~/LMStudio.AppImage "<latest AppImage download link from the official site>"
 
# Add execute permission
chmod +x ~/LMStudio.AppImage
 
# Move to application directory
mkdir -p ~/.local/bin
mv ~/LMStudio.AppImage ~/.local/bin/lmstudio
 
# Create desktop shortcut
# Note: .desktop Exec does not expand variables like $HOME; you must use an absolute path
# Replace YOUR_USER below with your username (the output of echo $USER)
cat > ~/.local/share/applications/lmstudio.desktop << 'EOF'
[Desktop Entry]
Name=LM Studio
Comment=Local LLM Management
Exec=/home/YOUR_USER/.local/bin/lmstudio --no-sandbox
Icon=lmstudio
Type=Application
Categories=Development;Science;
StartupNotify=true
EOF
 
# Launch LM Studio
~/.local/bin/lmstudio

Abhängigkeiten installieren


# LM Studio may require FUSE support (AppImage dependency)
sudo apt install -y libfuse2t64

GUI-Nutzung

Die Hauptfunktionsbereiche von LM Studio:

Entdecken – Suchen und laden Sie GGUF-Modelle von Hugging Face herunter
Chat – Laden Sie ein Modell und chatten Sie mit ihm
Entwickler – Starten Sie einen lokalen API-Server, der mit dem OpenAI-API-Format kompatibel ist

Starten Sie den lokalen API-Server:

Laden Sie auf der Registerkarte „Entwickler“ ein Modell und klicken Sie dann auf „Server starten“. Die Standardadresse ist http://localhost:1234.


# Test LM Studio's local API
curl http://localhost:1234/v1/chat/completions -d '{
  "model": "loaded-model-name",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}'

Note

LM Studio speichert Modelldateien im Verzeichnis ~/.lmstudio/models/. Große Modelldateien können mehrere zehn GB beanspruchen. Stellen Sie daher sicher, dass Sie über ausreichend Speicherplatz verfügen.

llama.cpp

llama.cpp ist die niedrigste lokale Inferenz-Engine, die in reinem C/C++ geschrieben ist und sowohl CPU- als auch GPU-Inferenz mit extrem hoher Leistung unterstützt. Das Backend von Ollama verwendet auch llama.cpp.

Aus der Quelle erstellen


# Install build dependencies
sudo apt install -y build-essential cmake git
 
# Clone the repository
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
 
# Method 1: CPU-only build
cmake -B build
cmake --build build --config Release -j$(nproc)
 
# Method 2: Enable CUDA GPU acceleration (recommended, requires CUDA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)
 
# Method 3: Enable Vulkan GPU acceleration (works with AMD/Intel/NVIDIA)
sudo apt install -y libvulkan-dev
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j$(nproc)

Modelle herunterladen


# llama.cpp uses GGUF format models
# Download from Hugging Face (Qwen 2.5 7B example)
mkdir -p ~/models
wget -O ~/models/qwen2.5-7b-q4_k_m.gguf \
  "https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf"

Befehlszeilen-Inferenz


# Interactive chat
./build/bin/llama-cli \
  -m ~/models/qwen2.5-7b-q4_k_m.gguf \
  -ngl 999 \
  -c 4096 \
  --interactive \
  --color
 
# Start an OpenAI-compatible API server
./build/bin/llama-server \
  -m ~/models/qwen2.5-7b-q4_k_m.gguf \
  -ngl 999 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080
 
# Parameter explanations:
# -m        Model file path
# -ngl 999  Use as many GPU layers as possible
# -c 4096   Context length
# --host    Listen address
# --port    Listen port


# Test the API server
curl http://localhost:8080/v1/chat/completions -d '{
  "model": "qwen2.5",
  "messages": [{"role": "user", "content": "Hello"}]
}'

Tip

GGUF-Modelldateien gibt es in verschiedenen Quantisierungsstufen. Q4_K_M bietet ein gutes Gleichgewicht zwischen Qualität und Dateigröße, Q5_K_M bietet eine höhere Qualität, aber größere Dateien, und Q8_0 kommt der ursprünglichen Präzision nahe. Für den täglichen Gebrauch wird Q4_K_M oder Q5_K_M empfohlen.

Jan

Jan ist ein lokaler Open-Source-KI-Chat-Client mit einer benutzerfreundlichen grafischen Oberfläche, der mehrere Modelle und lokale Inferenz unterstützt.

Installieren Sie Jan


# Download Jan deb package
wget -O /tmp/jan.deb "https://app.jan.ai/download/latest/linux-amd64-deb"
 
# Install
sudo dpkg -i /tmp/jan.deb
sudo apt install -f -y
 
# Launch Jan
jan


# Or install via AppImage
wget -O ~/jan.appimage "https://app.jan.ai/download/latest/linux-amd64-appimage"
chmod +x ~/jan.appimage
~/jan.appimage

Schnittstellennutzung

Die Hauptfunktionen von Jan:

Hub – Empfohlene Modelle durchsuchen und herunterladen (Download mit einem Klick)
Chat – Chatten Sie mit Models, unterstützt mehrere Sitzungen
Einstellungen – Konfigurieren Sie Modellparameter, GPU-Beschleunigung usw.

Jan unterstützt den Import benutzerdefinierter GGUF-Modelldateien. Platzieren Sie Modelldateien im Verzeichnis ~/jan/models/.


# Jan default data directory
ls ~/jan/
 
# Manually import a model
mkdir -p ~/jan/models/my-custom-model
cp ~/models/qwen2.5-7b-q4_k_m.gguf ~/jan/models/my-custom-model/

Jan stellt auch einen lokalen API-Server bereit. Wenn es aktiviert ist, ist es mit dem OpenAI-API-Format kompatibel und verwendet standardmäßig den Port 1337.

Open WebUI

Open WebUI ist eine funktionsreiche Webschnittstelle für die Interaktion mit lokalen Modellen, die Verbindungen zu Ollama und OpenAI-kompatiblen APIs unterstützt.

Docker Bereitstellung


# Ensure Docker is installed
sudo apt install -y docker.io docker-compose-v2
sudo usermod -aG docker $USER
newgrp docker
 
# Method 1: Connect to local Ollama (most common)
docker run -d \
  --name open-webui \
  --network=host \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://127.0.0.1:11434 \
  --restart always \
  ghcr.io/open-webui/open-webui:main
 
# Method 2: Bundled Ollama version (all-in-one deployment)
docker run -d \
  --name open-webui \
  --gpus all \
  -p 3000:8080 \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:ollama

Greifen Sie auf Open WebUI zu


# After deployment, open your browser
# Method 1 (--network=host): http://localhost:8080
# Method 2 (-p 3000:8080): http://localhost:3000
 
# First visit requires creating an admin account

Stellen Sie eine Verbindung zu Ollama her

Wenn Ollama und Open WebUI auf demselben Computer sind:


# Ensure Ollama is running
systemctl status ollama
 
# Open WebUI connects to http://localhost:11434 by default
# Confirm the Ollama URL in Open WebUI Settings > Connections

Docker Compose-Bereitstellung


# Create project directory
mkdir -p ~/open-webui && cd ~/open-webui
 
# Create docker-compose.yml
cat > docker-compose.yml << 'EOF'
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - WEBUI_AUTH=true
    volumes:
      - open-webui-data:/app/backend/data
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: always
 
volumes:
  open-webui-data:
EOF
 
# Start the service
docker compose up -d
 
# View logs
docker compose logs -f open-webui

Note

Open WebUI unterstützt Mehrbenutzerkonten, Konversationsverlauf, Modellverwaltung, RAG (Retrieval-Augmented Generation), Websuche und andere erweiterte Funktionen. Es ist eine der besten Webschnittstellen für Einzelpersonen und Teams, die lokale Modelle verwenden.

Modellvergleichstabelle

Hier ist ein Vergleich aktueller Mainstream-Open-Source-Modelle, um Ihnen bei der Auswahl zu helfen:

Modellreihe	Entwickler	Verfügbare Größen	chinesisch	Codierung	Argumentation	Lizenz
Lama 3.1/3.2	Meta	1B/3B/8B/70B/405B	Fair	Gut	Gut	Lama 3
Qwen 2.5	Alibaba	0,5B-72B	Exzellent	Exzellent	Gut	Apache 2.0
Qwen 2.5 Coder	Alibaba	1,5B-32B	Gut	Hervorragend	Gut	Apache 2.0
DeepSeek R1	DeepSeek	1,5B-671B	Exzellent	Exzellent	Hervorragend	MIT
DeepSeek V3	DeepSeek	671B	Exzellent	Exzellent	Exzellent	MIT
Mistral	Mistral	7B/8x7B/8x22B	Fair	Gut	Gut	Apache 2.0
Gemma 2	Google	2B/9B/27B	Fair	Gut	Gut	Gemma
Phi-3/4	Microsoft	3,8B-14B	Fair	Gut	Gut	MIT
Yi	01.AI	6B/9B/34B	Exzellent	Gut	Gut	Apache 2.0
GLM-4	Zhipu KI	9B	Exzellent	Gut	Gut	Brauch

Anwendungsfallempfehlungen

Täglicher chinesischer Chat (8 GB VRAM):


ollama pull qwen2.5:7b
ollama run qwen2.5:7b

Unterstützung beim Schreiben von Code (12 GB VRAM):


ollama pull qwen2.5-coder:14b
ollama run qwen2.5-coder:14b

Komplexe Denkaufgaben (16 GB+ VRAM):


ollama pull deepseek-r1:14b
ollama run deepseek-r1:14b

Nur CPU (keine GPU):


ollama pull qwen2.5:3b
ollama run qwen2.5:3b
 
# Or use an even smaller model
ollama pull llama3.2:1b
ollama run llama3.2:1b

Tip

Wenn Sie sich nicht sicher sind, welches Modell Sie wählen sollen, ist es eine gute Wahl, mit qwen2.5:7b zu beginnen. Es verfügt über gute Chinesischkenntnisse, einen moderaten Ressourcenverbrauch und ist für die meisten alltäglichen Anwendungsfälle geeignet. Bei Codierungsaufgaben ähnelt qwen2.5-coder:14b kommerziellen Modellen.