Rezepte für lokale LLMs

Recipe 1: Personal coding assistant (8 GB VRAM, 10 min)

Hardware: 8 GB VRAM GPU (RTX 3060, 4060 oder ähnlich) Use case: Code-Vervollständigung und Chat in Ihrem Editor Backend: Ollama + Continue oder Cline

Install Ollama and pull a 7B coder model

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

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

Verify the model responds

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
  }'

Install the Tokios connector and register a deployment

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

Im dashboard registrieren Sie ein Deployment namens my-coder, das auf den Upstream qwen2.5-coder:7b zeigt. Erstellen Sie einen API-Schlüssel.

Configure Continue or Cline

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

Erwartete Leistung: ~40 tok/s auf einer RTX 4060. Responsive Tab-Vervollständigung und Inline-Bearbeitungen mit 4K Kontext.

Recipe 2: Family chatbot server (16 GB VRAM, 15 min)

Hardware: 16 GB VRAM GPU (RTX 4080, 4070 Ti Super oder ähnlich) Use case: Selbstgehostete ChatGPT-ähnliche Oberfläche für den Haushalt Backend: Ollama + Open WebUI + Tokios

Start a 14B chat model with Ollama

ollama pull qwen2.5:14b

Run Open WebUI with Docker

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 erstellen Sie ein Admin-Konto.

Expose through Tokios for remote access

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

Registrieren Sie ein Deployment namens family-chat, das auf qwen2.5:14b zeigt. Erstellen Sie einen API-Schlüssel für jedes Familienmitglied — eingegrenzte Schlüssel ermöglichen es Ihnen, den Zugriff individuell zu widerrufen.

Erwartete Leistung: ~25 tok/s auf einer RTX 4080 mit 8K Kontext. Komfortabel für Multi-Turn-Gespräche.

Erstellen Sie separate API-Schlüssel pro Familienmitglied, damit Sie einen widerrufen können, ohne andere zu beeinträchtigen.

Recipe 3: Team API endpoint (48 GB+ VRAM, 30 min)

Hardware: 48 GB+ VRAM (A6000, 2x RTX 4090 oder A100) Use case: Gemeinsamer Modell-Endpunkt für ein Entwicklungsteam Backend: vLLM + Tokios

Install vLLM and launch a 70B model

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

Verify the server responds

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

Install the 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.

Registrieren Sie ein Deployment namens team-70b. Erstellen Sie auf dem Tab Keys 1 Schlüssel pro Teammitglied. Begrenzen Sie jeden Schlüssel auf das team-*-Muster, sodass Teammitglieder nur gemeinsame Deployments erreichen können.

Erwartete Leistung: ~30 tok/s aggregierter Durchsatz mit AWQ-Quantisierung. Bewältigt 3–5 gleichzeitige Anfragen mit akzeptabler Latenz.

Bei 2 GPUs bietet Tensor-Parallelität besseren Decode-Durchsatz als Pipeline-Parallelität auf einem einzelnen Knoten. Siehe Tensor vs Pipeline Parallelität.

Recipe 4: Document Q&A pipeline (24 GB VRAM, 45 min)

Hardware: 24 GB VRAM GPU (RTX 3090, 4090 oder ähnlich) Use case: Fragen zu Ihren PDFs und Dokumenten stellen, ohne sie in die Cloud zu senden Backend: Ollama (Embedding + Chat) + eigenes RAG-Skript + Tokios

Pull an embedding model and a 32B chat model

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

Das Embedding-Modell (~270 MB) erstellt Vektor-Darstellungen Ihrer Dokumente. Das 32B-Modell beantwortet Fragen, die auf diesen Embeddings basieren.

Build a simple 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"]

Expose the chat model through Tokios

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

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

Erwartete Leistung: ~15 tok/s für das 32B-Modell auf einer RTX 4090. Embedding ist für kurze Passagen nahezu sofort.

Halten Sie das Embedding-Modell lokal (es ist schnell und klein) und leiten Sie nur das Chat-Modell über Tokios. Das vermeidet das Senden von Dokumententext über das Netzwerk für Embedding.

Recipe 5: DGX Spark max throughput (128 GB, 20 min)

Hardware: NVIDIA DGX Spark (128 GB einheitlicher Speicher) Use case: Maximaler Durchsatz für große MoE-Modelle Backend: vLLM + 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 einheitliche Speicher des DGX Spark fasst Modelle, für die 2–3 Consumer-GPUs benötigt werden. MoE-Modelle wie Qwen3-235B-A22B aktivieren nur ~22B Parameter pro Token, daher ist die Inferenz trotz großer Gesamtparameterzahl schnell.

Verify and benchmark

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
  }'

Expose through Tokios

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

Registrieren Sie ein Deployment namens spark-moe. Erstellen Sie Schlüssel für jeden Client, der Zugriff benötigt.

Erwartete Leistung: ~35 tok/s auf DGX Spark für den aktiven Parametersatz. 16K Kontext passt bequem in den einheitlichen Speicher.

Siehe vLLM auf DGX Spark und DGX Spark Speicher-Tuning für detaillierte Konfigurationsoptionen.

Recipe 6: Laptop-friendly offline AI (16 GB RAM, 5 min)

Hardware: Beliebiger Laptop mit 16 GB RAM (keine dedizierte GPU erforderlich) Use case: Privater KI-Assistent, der ohne Internet funktioniert Backend: Ollama (CPU-Modus)

Install Ollama and pull a quantized 7B model

# 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

Q4_K_M-Quantisierung hält das Modell unter 5 GB, also läuft es auf CPU mit 16 GB RAM.

Chat locally — no internet required

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

Das war’s. Das Modell läuft vollständig auf Ihrem Laptop. Keine Netzwerkaufrufe, keine Telemetrie, keine API-Schlüssel.

Optionally expose through Tokios when online

Wenn Sie Internet haben und das Modell von einem anderen Gerät aus erreichen wollen:

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

Registrieren Sie ein Deployment namens laptop-offline. Der Connector wählt sich nur hinaus, wenn das Netzwerk verfügbar ist — offline funktioniert Ihr Modell weiterhin lokal.

Erwartete Leistung: ~5 tok/s auf CPU (moderner Laptop). Nutzbar für Chat und Entwürfe, nicht für Echtzeit-Coding-Hilfe.

Wenn Ihr Laptop einen Apple-Silicon-Chip hat, verwendet Ollama automatisch Neural Engine und Metal — erwarten Sie 20–30 tok/s auf M-Series-Chips.

Recipe 7: Multi-model routing (24 GB+ VRAM, 30 min)

Hardware: 24 GB+ VRAM GPU Use case: 3 Modelle verschiedener Größen über 1 Tokios-Endpunkt bereitstellen Backend: Ollama oder vLLM + Tokios mit Konfigurationsdatei

Pull 3 models at different sizes

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

Create a multi-route connector config

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 auf dem Tab Models:

Deployment-Name	Upstream-Modell-ID
`fast-small`	`qwen2.5:3b`
`medium`	`qwen2.5:14b`
`large`	`qwen2.5:32b`

Route by sending the model field

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 unter 1 Sekunde. Das 32B-Modell braucht 2–3 Sekunden für das erste Token, liefert aber höhere Qualität. Derselbe Endpunkt, derselbe Schlüssel, verschiedenes model-Feld.

Ollama hält standardmäßig nur 1 Modell gleichzeitig im VRAM und tauscht bei Anfrage aus. Wenn Sie alle 3 gleichzeitig geladen brauchen, betreiben Sie separate Backends oder verwenden Sie vLLM mit LoRA-Adaptern. Siehe Modell-Routing.

Recipe 8: Benchmarking your setup (any hardware, 10 min)

Hardware: Beliebige GPU oder CPU, die ein lokales Modell betreibt Use case: Durchsatz und Latenz über Modelle, Quantisierungen oder Hardware hinweg vergleichen Backend: Beliebig + Tokios

Start your model server

Verwenden Sie ein beliebiges Backend — Ollama, vLLM, llama.cpp oder LM Studio. Bestätigen Sie, dass es auf seinem /v1-Endpunkt antwortet.

Run a throughput benchmark

# 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

Benchmark through Tokios to measure end-to-end latency

# 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']}\")
"

Compare quantizations

Laden Sie dasselbe Modell in verschiedenen Quantisierungen und benchmarken Sie jede:

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 jede und vergleichen Sie Tokens pro Sekunde. Q5_K_M bietet bei 7B typischerweise das beste Qualität-zu-Geschwindigkeit-Verhältnis.

Erwartete Ergebnisse: Der Tunnel fügt 50–150 ms Latenz pro Anfrage hinzu (1 Roundtrip zum Tokios-Gateway). Streaming-Durchsatz ist nahezu identisch mit lokal — der Tunnel puffert kein SSE.

Für einen strukturierteren Benchmark siehe Deployment testen.

Fallstudien

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

Ein lokales Modell wählen

Wählen Sie das richtige Modell und die Quantisierung für Ihre Hardware und Ihren Workflow.

Modell-Routing

Registrieren Sie mehrere Deployments und wechseln Sie Modelle durch Ändern des Modell-Felds.

Schnellstart

Gehen Sie von null zu einem funktionierenden Connector, Deployment und API-Schlüssel.

Erste Schritte

Modelle

Konzepte

Referenz

Rezepte für lokale LLMs

Nächste Schritte

Fallstudien

Ein lokales Modell wählen

Modell-Routing

Schnellstart

​Nächste Schritte

Fallstudien

Ein lokales Modell wählen

Modell-Routing

Schnellstart

Nächste Schritte