Rezepte für lokale LLMs

Rezept 1: Persönlicher Programmier-Assistent (8 GB VRAM, mindestens 10)

Hardware: 8 GB VRAM-fähige GPU (RTX 3060, 4060 oder vergleichbare Modelle) Anwendungsfall: Automatische Codevervollständigung sowie Chat-Funktionen direkt in Ihrem Editor Backend: Ollama in Kombination mit Continue oder Cline

Installieren Sie Ollama und laden Sie ein 7B-Coder-Modell herunter.

# Install Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Pull a coding-optimized 7B model
ollama pull qwen2.5-coder:7b

Überprüfen Sie, ob das Modell reagiert.

curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder:7b",
    "messages": [{"role": "user", "content": "Write a Python hello world"}],
    "max_tokens": 100
  }'

Installieren Sie den Tokios-Connector und registrieren Sie eine Deployment.

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Geben Sie im dashboard eine Deployment mit dem Namen my-coder an, die auf den Upstream-Modell-ID qwen2.5-coder:7b verweist. Erstellen Sie anschließend einen API-Schlüssel.

Konfigurieren Sie nun Continue bzw. Cline.

{
  "baseURL": "https://api.tokios.com/v1",
  "apiKey": "sk-tok-YOUR_KEY",
  "model": "my-coder"
}

Erwartete Leistung: Etwa 40 Tokens pro Sekunde auf einer RTX 4060. Schnelle Tab-Vervollständigung sowie Inline-Bearbeitungen mit 4K Kontext.

Rezept 2: Chatbot-Server für die Familie (16 GB VRAM, mindestens 15 Minuten).

Hardware: 16 GB VRAM-fähige GPU (RTX 4080, 4070 Ti Super oder vergleichbare Modelle) Anwendungsfall: Selbstgehostete Schnittstelle im Stil von ChatGPT für den privaten Gebrauch Backend: Ollama sowie Open WebUI und Tokios

Starten Sie ein 14B-Chat-Modell mithilfe von Ollama.

ollama pull qwen2.5:14b

Führen Sie Open WebUI via Docker aus.

docker run -d \
  --name open-webui \
  -p 3000:8080 \
  -e OLLAMA_BASE_URL=http://host.docker.internal:11434 \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Öffnen Sie http://localhost:3000 und legen Sie ein Administratorkonto an.

Stellen Sie mittels Tokios eine externe Zugriffsmöglichkeit bereit.

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Erstellen Sie eine Deployment namens family-chat, das auf qwen2.5:14b verweist. Generieren Sie für jedes Familienmitglied einen API-Schlüssel; durch begrenzte Berechtigungen lässt sich der Zugriff einzeln entziehen.

Erwartete Leistung: Etwa 25 Tokens pro Sekunde auf einer RTX 4080 bei 8K Kontext. Ideal für mehrfache Dialoge.

Erstellen Sie für jedes Familienmitglied einen eigenen API-Schlüssel, sodass Sie Zugriffe separat entziehen können.

Rezept 3: API-Endpunkt für Teams (mindestens 48 GB VRAM, mindestens 30 Minuten).

Hardware: 48 GB oder mehr an VRAM (A6000, 2x RTX 4090 oder A100) Anwendungsfall: Gemeinsamer Modell-Endpoint für ein Entwicklerteam Backend: vLLM sowie Tokios

Installieren Sie vLLM und starten Sie ein 70B-Modell.

pip install vllm

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization awq \
  --tensor-parallel-size 2 \
  --gpu-memory-utilization 0.90 \
  --max-model-len 8192

Überprüfen Sie, ob der Server reagiert.

curl http://127.0.0.1:8000/v1/models

Installieren Sie den Tokios-Connector.

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Richten Sie den Connector auf http://127.0.0.1:8000/v1 aus.

Erstellen Sie eine Deployment sowie zugehörige API-Schlüssel mit begrenzten Berechtigungen.

Legen Sie eine Deployment namens team-70b an. Auf der Keys-Registerkarte erstellen Sie für jedes Teammitglied einen 1-Schlüssel. Weisen Sie jedem Schlüssel das team-*-Muster zu, sodass Teammitglieder ausschließlich auf gemeinsame Deployment zugreifen können.

Erwartete Leistung: Mithilfe der AWQ-Quantisierung erzielt man eine Gesamtdurchsatzrate von rund 30 Tokens pro Sekunde. Zudem können bis zu 3 bis 5 gleichzeitige Anfragen mit akzeptabler Latenz verarbeitet werden.

Bei Verwendung von 2 GPUs führt Tensor-Parallelismus auf einem einzelnen Knoten zu höherem Decodier-Durchsatz als Pipeline-Parallelismus. Weitere Informationen finden Sie unter Tensor- vs. Pipeline-Parallelismus.

Rezept 4: Dokumentation für die Q&A-Pipeline (benötigt 24 GB VRAM; Dauer: 45 Minuten).

Hardware: 24 GB VRAM-Grafikkarte (RTX 3090, 4090 oder vergleichbare Modelle) Anwendungsfall: Stellen Sie Fragen zu Ihren PDF-Dateien und Dokumenten, ohne sie in die Cloud hochzuladen Backend: Ollama (für Vektor-Embeddings und Chat-Funktionen) sowie ein individuell entwickeltes RAG-Skript und Tokios

Laden Sie ein Embedding-Modell sowie ein 32B-Chat-Modell herunter.

ollama pull nomic-embed-text
ollama pull qwen2.5:32b

Das Embedding-Modell (Größe: rund 270 MB) erstellt Vektordarstellungen Ihrer Dokumente. Das 32B-Modell beantwortet anschließend Fragen anhand dieser Vektoren.

Erstellen Sie eine einfache RAG-Pipeline

import requests, json

EMBED_MODEL = "nomic-embed-text"
CHAT_MODEL  = "qwen2.5:32b"
OLLAMA_URL  = "http://127.0.0.1:11434"

def embed(text: str) -> list[float]:
    r = requests.post(f"{OLLAMA_URL}/api/embeddings",
                       json={"model": EMBED_MODEL, "prompt": text})
    return r.json()["embedding"]

def ask(question: str, context: str) -> str:
    prompt = f"Answer based on this context:\n\n{context}\n\nQuestion: {question}"
    r = requests.post(f"{OLLAMA_URL}/v1/chat/completions",
                       json={"model": CHAT_MODEL,
                             "messages": [{"role": "user", "content": prompt}],
                             "max_tokens": 512})
    return r.json()["choices"][0]["message"]["content"]

Stellen Sie das Chat-Modell über Tokios bereit

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Registrieren Sie eine Deployment namens doc-qa, die auf qwen2.5:32b verweist. Ihr RAG-Skript kann das Modell nun über https://api.tokios.com/v1 von jedem Rechner aus aufrufen, während die Embeddings lokal verbleiben.

Erwartete Leistung: Etwa 15 Tokens pro Sekunde für das 32B-Modell auf einer RTX 4090. Bei kurzen Textabschnitten erfolgt die Embedding-Berechnung nahezu unmittelbar.

Behalten Sie das Embedding-Modell lokal – es ist schnell und kompakt – und leiten Sie lediglich das Chat-Modell über Tokios um. Auf diese Weise werden Dokumenttexte nicht über das Netzwerk zur Embedding-Berechnung gesendet.

Rezept 5: Maximale Durchsatzrate mit DGX Spark (128 GB, 20 Minuten)

Hardware: NVIDIA DGX Spark (128 GB gemeinsamer Speicher) Anwendungsfall: Maximale Durchsatzrate für große MoE-Modelle Backend: vLLM in Kombination mit Tokios

Launch a 120B MoE model at FP8

vllm serve Qwen/Qwen3-235B-A22B-FP8 \
  --host 127.0.0.1 \
  --port 8000 \
  --quantization fp8 \
  --gpu-memory-utilization 0.85 \
  --max-model-len 16384 \
  --trust-remote-code

Der 128 GB große gemeinsame Speicher der DGX Spark reicht für Modelle aus, die 2 bis 3 herkömmliche GPUs benötigen. Bei MoE-Modellen wie Qwen3-235B-A22B werden pro Token lediglich ~22B Parameter aktiviert, wodurch die Inferenzgeschwindigkeit trotz hoher Gesamtparameterzahl hoch bleibt.

Überprüfen und Leistungstests durchführen

curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-235B-A22B-FP8",
    "messages": [{"role": "user", "content": "Explain quantum entanglement"}],
    "max_tokens": 256
  }'

Über Tokios bereitstellen

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Registrieren Sie eine Deployment namens spark-moe. Erstellen Sie anschließend API-Schlüssel für alle Clients, die Zugriff benötigen.

Erwartete Leistung: Etwa 35 Tokens pro Sekunde auf dem DGX Spark bei der aktuellen Parameterkonfiguration. Der Kontext von 16K Einheiten passt problemlos in den gemeinsamen Speicher.

Weitere Informationen zu Konfigurationsmöglichkeiten finden Sie unter vLLM auf dem DGX Spark sowie Speichereinstellungen für den DGX Spark.

Rezept 6: Eine offline-fähige KI für Laptops (benötigt 16 GB Arbeitsspeicher, benötigte Zeit: mindestens 5 Minuten).

Hardware: Jeder Laptop mit mindestens 16 GB Arbeitsspeicher – eine dedizierte GPU ist nicht erforderlich. Anwendungsfall: Ein privater KI-Assistent, der ohne Internetverbindung arbeitet. Backend: Ollama im CPU-Modus.

Installieren Sie Ollama und laden Sie ein quantisiertes 7B-Modell herunter.

# macOS
curl -fsSL https://ollama.com/install.sh | sh

# Or download from https://ollama.com for Windows/Linux
ollama pull qwen2.5:7b-instruct-q4_K_M

Die Quantisierungsstufe Q4_K_M hält den Speicherbedarf des Modells unter 5 GB, sodass es auf einem System mit nur 16 GB Arbeitsspeicher lauffähig ist.

Führen Sie Gespräche lokal – dafür ist keine Internetverbindung nötig.

ollama run qwen2.5:7b-instruct-q4_K_M

Das war’s. Das Modell läuft vollständig auf Ihrem Laptop; es erfolgen weder Netzwerkabfragen noch Telemetriedatenübertragungen, und es werden keine API-Schlüssel benötigt.

Falls gewünscht, kann das Modell online über Tokios zugänglich gemacht werden.

Falls Sie eine Internetverbindung haben und das Modell von einem anderen Gerät aus nutzen möchten:

curl -fsSL https://tokios.com/downloads/install/linux | sh -s -- --code TKS-XXXX-XXXX

Erstellen Sie eine Deployment mit dem Namen laptop-offline. Der Connector initiiert Verbindungen nur, wenn ein Netzwerk verfügbar ist; im Offline-Modus arbeitet Ihr Modell weiterhin lokal.

Erwartete Leistung: Etwa 5 Tokens pro Sekunde auf der CPU moderner Laptops. Dies reicht für Gespräche und das Entwurfen von Texten aus, doch nicht für Echtzeit-Unterstützung beim Programmieren.

Falls Ihr Laptop über einen Apple-Silicon-Chip verfügt, nutzt Ollama automatisch den Neural Engine sowie Metal – auf M-Serie-Chips erzielen Sie dabei 20 bis 30 Tokens pro Sekunde.

Rezept 7: Mehrfachmodell-Routing (erfordert 24 GB oder mehr VRAM, mindestens 30 Minuten Wartezeit)

Hardware: 24 GB+ VRAM GPU Use case: Serve 3 models of different sizes through 1 Tokios endpoint Backend: Ollama or vLLM + Tokios with config file

Laden Sie verschiedene Modelle unterschiedlicher Größe mittels 3 herunter.

ollama pull qwen2.5:3b     # fast-small: quick classification
ollama pull qwen2.5:14b    # medium: general chat
ollama pull qwen2.5:32b    # large: complex reasoning

Erstellen Sie eine Konfiguration für einen Multi-Route-Connector.

Erstellen Sie tokios-connector.json:

{
  "Routes": [
    { "Deployment": "fast-small", "Upstream": "local-ollama" },
    { "Deployment": "medium",     "Upstream": "local-ollama" },
    { "Deployment": "large",      "Upstream": "local-ollama" }
  ],
  "Upstreams": {
    "local-ollama": {
      "BaseUrl": "http://127.0.0.1:11434/v1"
    }
  }
}

Registrieren Sie alle 3 Deployments im Dashboard.

Unter dem Reiter Models führen Sie folgende Registrierungen durch:

Bezeichnung des Deployments	Upstream-Modell-ID
`fast-small`	`qwen2.5:3b`
`medium`	`qwen2.5:14b`
`large`	`qwen2.5:32b`

Routing erfolgt durch Angabe des Modellfeldes.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.tokios.com/v1",
    api_key="sk-tok-YOUR_KEY",
)

# Fast classification
client.chat.completions.create(
    model="fast-small",
    messages=[{"role": "user", "content": "Is this email spam? ..."}],
)

# Complex reasoning
client.chat.completions.create(
    model="large",
    messages=[{"role": "user", "content": "Analyze this contract clause..."}],
)

Erwartete Leistung: Das 3B-Modell antwortet in weniger als 1 Sekunden. Das 32B-Modell benötigt 2 bis 3 Sekunden für das erste Token, liefert jedoch qualitativ hochwertigere Ergebnisse. Derselbe Endpunkt, derselbe API-Schlüssel – lediglich das model-Feld unterscheidet sich.

Standardmäßig speichert Ollama nur 1 Modell gleichzeitig im VRAM und lädt bei Bedarf andere Modelle nach. Falls Sie alle 3 Modelle gleichzeitig nutzen möchten, starten Sie separate Backends oder verwenden Sie vLLM mit LoRA-Adaptern. Weitere Informationen finden Sie unter Model-Routing.

Rezept 8: Durchführung eines Benchmarks Ihrer Setup-Konfiguration (für beliebige Hardware, mindestens 10 Minuten)

Hardware: Jede GPU oder CPU, die ein lokales Modell ausführen kann Anwendungsfall: Vergleich von Durchsatz und Latenz zwischen verschiedenen Modellen, Quantisierungen sowie Hardware-Konfigurationen Backend: Beliebiges Backend in Kombination mit Tokios

Starten Sie Ihren Modell-Server.

Nutzen Sie beliebige Backends – Ollama, vLLM, llama.cpp oder LM Studio. Stellen Sie sicher, dass sie auf dem entsprechenden /v1-Endpunkt reagieren.

Führen Sie einen Durchsatz-Benchmark durch.

# Simple throughput test with curl and timing
for i in 1 2 3 4 5; do
  time curl -s http://127.0.0.1:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
      "model": "qwen2.5:7b",
      "messages": [{"role": "user", "content": "Write a 200-word essay about recursion"}],
      "max_tokens": 256,
      "stream": false
    }' | python3 -c "
import sys, json
r = json.load(sys.stdin)
u = r['usage']
print(f\"Tokens: {u['completion_tokens']}, Time: check wall clock\")
"
done

Nutzen Sie Tokios, um die End-to-End-Latenz zu messen.

# Same test through the Tokios endpoint
time curl -s https://api.tokios.com/v1/chat/completions \
  -H "Authorization: Bearer sk-tok-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "my-deployment",
    "messages": [{"role": "user", "content": "Write a 200-word essay about recursion"}],
    "max_tokens": 256,
    "stream": false
  }' | python3 -c "
import sys, json
r = json.load(sys.stdin)
u = r['usage']
print(f\"Tokens: {u['completion_tokens']}\")
"

Vergleichen Sie verschiedene Quantisierungsstufen.

Laden Sie dasselbe Modell in unterschiedlichen Quantisierungen und testen Sie jeweils deren Leistung.

ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:7b-instruct-q5_K_M
ollama pull qwen2.5:7b-instruct-q8_0

Senden Sie denselben Prompt an alle Varianten und vergleichen Sie die Anzahl der pro Sekunde generierten Tokens. Q5_K_M bietet in der Regel das beste Verhältnis zwischen Qualität und Geschwindigkeit bei 7B.

Erwartete Ergebnisse: Der Tunnel erhöht die Latenz pro Anfrage um 50 bis 150 Millisekunden (1 Hin- und Rückweg zum Tokios-Gateway). Der Durchsatz bei Streaming bleibt nahezu identisch mit dem lokalen Betrieb – der Tunnel puffert keine SSE-Daten.

Für einen strukturierteren Benchmark lesen Sie bitte Ihre Deployment-Konfiguration testen.

Fallbeispiele

Reale Deployment-Muster von Teams und Einzelpersonen, die lokale Modelle nutzen.

Ein lokales Modell auswählen

Wählen Sie das passende Modell samt Quantisierung für Ihre Hardware und Arbeitsabläufe.

Modell-Routing

Registrieren Sie mehrere Deployments und wechseln Sie Modelle, indem Sie den Upstream-Modell-ID-Feldwert anpassen.

Schnellstart

Richten Sie in wenigen Schritten einen funktionierenden Connector, eine Deployment-Instanz sowie einen API-Schlüssel ein.

Erste Schritte

Modelle

Konzepte

Referenz

Rezepte für lokale LLMs

Nächste Schritte

Fallbeispiele

Ein lokales Modell auswählen

Modell-Routing

Schnellstart

​Nächste Schritte

Fallbeispiele

Ein lokales Modell auswählen

Modell-Routing

Schnellstart

Nächste Schritte