Wichtigste Erkenntnisse
- Xinference bedient über 30 Modellfamilien über eine einzige API — Llama 3, Qwen 2.5, ChatGLM4, Mistral, Embedding-Modelle und Reranker teilen denselben Endpunkt auf localhost:9997/v1.
- Ein pip install, ein CLI-Befehl — `pip install "xinference[all]"` dann `xinference-local` startet den Server mit Web-Oberfläche; `xinference launch --model-name <Name>` deployt jedes Modell.
- Drei wählbare Backends — `transformers` (GPU, volle Präzision), `llama.cpp` (CPU + quantisiertes GGUF, kein GPU erforderlich), `vllm` (hoher Durchsatz, mehrere GPUs). Pro Modell konfigurierbar.
- Qwen 2.5 und ChatGLM4 sind die besten Xinference-Optionen für CJK-Aufgaben — beide laufen in ~6–7 GB VRAM und übertreffen vergleichbare englischsprachige Modelle auf chinesischen und japanischen Benchmarks.
- Bevorzuge Xinference gegenüber Ollama, wenn du Multi-Modell-Serving, Embedding + Reranking oder GPU-Cluster-Unterstützung benötigst — Ollama ist besser für einfache Desktop-Nutzung.
Was Xinference ist und wie es funktioniert
Xinference (github.com/xorbitsai/inference) ist ein Open-Source-Framework für LLM- und multimodale Modellbereitstellung von Xorbits. Es wurde als Enterprise-Inferenzplattform für verteilte Cluster entwickelt und 2023 als Open Source veröffentlicht. Kernidee: Du registrierst ein Modell nach Name, Xinference lädt die Gewichte herunter, wählt das richtige Backend und stellt eine REST-API bereit.
📍 In einem Satz
Xinference ist ein Open-Source-Inferenz-Server, der Llama 3, Qwen 2.5, ChatGLM4, Mistral und über 30 weitere Modellfamilien nativ über eine einzige OpenAI-kompatible API unterstützt.
💬 In einfachen Worten
Stell dir Xinference als eine Vermittlungsstelle für lokale KI-Modelle vor. Du sagst ihr, welches Modell geladen werden soll, sie lädt es herunter und startet es — deine App kommuniziert damit wie mit der OpenAI-API, ohne Code-Änderungen.
- Modell-Registrierung: Über 200 vorregistrierte Modelle. Referenzierung nach Name (`llama-3.1-instruct`, `qwen2.5-instruct`, `chatglm4`) statt manueller Gewichtspfad-Verwaltung.
- Backend-Abstraktion: Ein Befehl wechselt zwischen transformers-, llama.cpp- und vLLM-Backends — dieselbe API unabhängig vom Backend.
- Multi-Modell-Parallelität: Llama 3 für Textgenerierung und ein BGE-Embedding-Modell für RAG gleichzeitig auf derselben GPU.
- Web-Oberfläche: Ein React-Dashboard auf localhost:9997 zum Starten, Inspizieren und Beenden von Modellen ohne Code.
- Cluster-Modus: Supervisor-Worker-Architektur skaliert über mehrere GPU-Knoten via `xinference start --host 0.0.0.0` auf Workers.
Unterstützte Modellfamilien: Llama 3, Qwen, ChatGLM, Mistral
Die folgende Tabelle zeigt die sieben meistgefragten Modellkonfigurationen in Xinference mit dem minimal erforderlichen VRAM. Alle sieben teilen dasselbe Befehlsmuster — nur `--model-name`, `--model-size-in-billions` und optional `--quantization` ändern sich.
📍 In einem Satz
Xinference unterstützt nativ Llama 3.1 (8B/70B), Qwen 2.5 (7B/72B), ChatGLM4 9B, Mistral 7B v0.3 und Mixtral 8x7B — jedes mit einem einzigen CLI-Befehl startbar.
💬 In einfachen Worten
VRAM ist der Speicher auf Ihrer GPU. Ein Modell, das 6 GB VRAM benötigt, braucht eine GPU mit mindestens diesem Speicher. Bei kleineren GPUs nutzen Sie das llama.cpp-Backend mit Q4-Quantisierung, was den Speicherbedarf etwa halbiert.
| Modell | Familie | VRAM (Q4) | Backend | Am besten für |
|---|---|---|---|---|
| llama-3.1-instruct 8B | Meta | ~6 GB | transformers / llama.cpp | Allgemeiner Englisch-Einsatz |
| llama-3.1-instruct 70B | Meta | ~40 GB | vLLM | Hochwertige englische Ausgabe |
| qwen2.5-instruct 7B | Alibaba | ~6 GB | transformers / llama.cpp | Mehrsprachig, CJK, Programmierung |
| qwen2.5-instruct 72B | Alibaba | ~40 GB | vLLM | Großmaßstäbliche CJK-Aufgaben |
| chatglm4 9B | Zhipu AI | ~7 GB | transformers | Chinesische Unternehmensaufgaben |
| mistral-instruct-v0.3 7B | Mistral AI | ~5 GB | transformers / llama.cpp | Europäische Sprachen, Funktionsaufruf |
| mixtral-instruct-v0.1 8x7B | Mistral AI | ~26 GB | vLLM | Hochwertige Mehrsprachigkeit |
Unterstützt Xinference Llama 3.1?
Ja. Verwenden Sie `--model-name llama-3.1-instruct` mit `--model-size-in-billions 8` für die 8B-Variante oder `70` für 70B. Wechseln Sie zu llama.cpp mit `--model-engine llama.cpp` und `--quantization q4_k_m` für CPU- oder Low-VRAM-Nutzung.
Unterstützt Xinference Qwen 2.5?
Ja. Qwen 2.5 Instruct ist als `qwen2.5-instruct` registriert. Größen 0,5B bis 72B sind verfügbar. Die 7B-Variante läuft in ~6 GB VRAM und verarbeitet Chinesisch, Japanisch, Koreanisch und Englisch mit vergleichbarer Qualität zu Llama 3.1 8B.
Unterstützt Xinference ChatGLM?
Ja. ChatGLM3 (`chatglm3`), ChatGLM4 (`chatglm4`) und ChatGLM4-Vision (`chatglm4v`) sind alle registriert. ChatGLM4 9B ist 2026 die empfohlene Wahl für chinesischsprachige Aufgaben.
Unterstützt Xinference Mistral?
Ja. `mistral-instruct-v0.3` (7B) und `mixtral-instruct-v0.1` (8x7B MoE) sind beide registriert. Für Funktionsaufruf und JSON-Ausgabe ist Mistral 7B v0.3 die beste Kleinmodell-Option in Xinference.
Xinference installieren: pip und Server starten
Xinference erfordert Python 3.9+ und pip. Das `[all]`-Extra installiert CUDA-Unterstützung, das llama.cpp-Backend und das transformers-Backend in einem Schritt. Auf reinen CPU-Maschinen verwenden Sie `pip install xinference` (ohne `[all]`) und fügen `--model-engine llama.cpp` beim Modellstart hinzu.
📍 In einem Satz
Installiere Xinference mit `pip install "xinference[all]"` und starte den Server mit `xinference-local` — die Web-Oberfläche öffnet sich auf http://localhost:9997.
# Vollständige Installation — CUDA + transformers + llama.cpp Backends
pip install "xinference[all]"
# Nur-CPU-Installation (kein GPU erforderlich)
pip install xinference
# Lokalen Server starten (Web-Oberfläche auf http://localhost:9997)
xinference-local
# Oder an bestimmten Host für LAN-Zugriff binden
xinference-local --host 0.0.0.0 --port 9997Benötigt Xinference eine GPU?
Nein. Verwenden Sie das llama.cpp-Backend (`--model-engine llama.cpp`), um quantisierte GGUF-Modelle vollständig auf der CPU auszuführen. Die Performance ist langsamer als GPU-Inferenz, funktioniert aber auf jeder Maschine mit Python 3.9+.
Wie aktualisiere ich Xinference?
Führen Sie `pip install --upgrade xinference` aus. Prüfen Sie vor dem Upgrade die GitHub-Releases auf Breaking Changes, besonders im Cluster-Modus.
Llama 3, Qwen, ChatGLM und Mistral starten
Verwenden Sie `xinference launch`, um jedes registrierte Modell zu deployen. Das Muster ist immer dasselbe: `--model-name` setzt die Modellfamilie, `--model-size-in-billions` die Parameteranzahl, und `--model-engine` wählt das Backend. Nach dem Start gibt Xinference eine Modell-UID zurück, die Sie in API-Aufrufen verwenden.
📍 In einem Satz
Starte jedes Xinference-Modell mit `xinference launch --model-name <Name> --model-engine transformers --model-size-in-billions <Größe>` — das Modell ist kurz nach dem Download auf localhost:9997/v1 verfügbar.
# Llama 3.1 8B Instruct (GPU, transformers backend)
xinference launch \
--model-name llama-3.1-instruct \
--model-engine transformers \
--model-size-in-billions 8
# Llama 3.1 8B Instruct (CPU, Q4_K_M quantization)
xinference launch \
--model-name llama-3.1-instruct \
--model-engine llama.cpp \
--model-size-in-billions 8 \
--quantization q4_k_m
# Qwen 2.5 7B Instruct (GPU)
xinference launch \
--model-name qwen2.5-instruct \
--model-engine transformers \
--model-size-in-billions 7
# ChatGLM4 9B (GPU)
xinference launch \
--model-name chatglm4 \
--model-engine transformers \
--model-size-in-billions 9
# Mistral 7B Instruct v0.3 (GPU)
xinference launch \
--model-name mistral-instruct-v0.3 \
--model-engine transformers \
--model-size-in-billions 7
# Mixtral 8x7B Instruct (vLLM backend, requires 26+ GB VRAM)
xinference launch \
--model-name mixtral-instruct-v0.1 \
--model-engine vllm \
--model-size-in-billions 46Wie liste ich alle von Xinference unterstützten Modelle auf?
Führe `xinference registrations --model-type LLM` aus, oder öffne die Web-Oberfläche auf http://localhost:9997 und durchsuche die Modellbibliothek.
Kann ich in Xinference gleichzeitig zwei Modelle ausführen?
Ja — führe `xinference launch` zweimal mit verschiedenen Modellnamen aus. Jedes Modell erhält eine eigene UID und einen eigenen Endpunkt. Das gesamte VRAM-Budget muss beide Modelle gleichzeitig abdecken.
Die OpenAI-kompatible API verwenden
Xinferences API ist ein Drop-in-Ersatz für die OpenAI-API. Zeige jeden OpenAI-Client auf `http://localhost:9997/v1`, setze `api_key` auf einen beliebigen nicht leeren String, und verwende die Modell-UID als `model`-Parameter. Bestehender LangChain-, LlamaIndex- oder benutzerdefinierter OpenAI-Client-Code funktioniert unverändert.
📍 In einem Satz
Verbinde jeden OpenAI-kompatiblen Client mit Xinference, indem du base_url auf http://localhost:9997/v1 setzt und den Modellnamen als Modell-ID verwendest.
💬 In einfachen Worten
Eine OpenAI-kompatible API bedeutet, dass sich dein Code nicht ändern muss. Derselbe Python-Code, der GPT-4 aufruft, kann über Xinference Llama 3 aufrufen — du tauschst nur die Basis-URL und den Modellnamen aus.
from openai import OpenAI
client = OpenAI(
api_key="not-required", # Xinference accepts any non-empty string
base_url="http://localhost:9997/v1"
)
# Chat completion — works for Llama 3, Qwen, ChatGLM, Mistral
response = client.chat.completions.create(
model="llama-3.1-instruct",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Summarise the GDPR in 3 bullet points."}
]
)
print(response.choices[0].message.content)
# Embedding model (run a separate xinference launch for bge-base-en-v1.5 first)
embedding = client.embeddings.create(
model="bge-base-en-v1.5",
input="Local LLMs preserve data privacy."
)
print(embedding.data[0].embedding[:5])Unterstützt Xinference Streaming-Antworten?
Ja. Setze `stream=True` im `chat.completions.create`-Aufruf. Xinference streamt Tokens in Echtzeit für alle unterstützten Backends.
Kann ich LangChain mit Xinference verwenden?
Ja. Verwende `ChatOpenAI(base_url="http://localhost:9997/v1", api_key="x", model="llama-3.1-instruct")` aus `langchain_openai`. Es ist keine zusätzliche Xinference-spezifische Bibliothek erforderlich.
Xinference vs. Ollama vs. vLLM: Wann welches Framework wählen
Die drei häufigsten lokalen Inferenz-Frameworks richten sich jeweils an unterschiedliche Nutzergruppen. Wähle anhand deiner primären Anforderung.
📍 In einem Satz
Wähle Xinference, wenn du mehrere Modelltypen gleichzeitig bereitstellen musst (LLM + Embeddings + Reranker) oder nativen ChatGLM-Support benötigst — wähle Ollama für einfache Desktop-Nutzung.
| Kriterium | Xinference | Ollama | vLLM |
|---|---|---|---|
| Am besten für | Teams, Multi-Modell, Embeddings + LLM | Einzelnutzer-Desktop, Modelfile-Workflows | Hoher GPU-Durchsatz |
| GPU erforderlich? | Nein (llama.cpp-Backend) | Nein (CPU-Modus verfügbar) | Ja (CUDA/ROCm) |
| Modellwechsel | Mehrere Modelle gleichzeitig | Ein Modell gleichzeitig (Swap) | Ein Modell pro Server-Instanz |
| Embedding-Unterstützung | Ja (BGE, E5 usw.) | Ja (eingeschränkt) | Nein (separater Embedding-Server) |
| Web-Oberfläche | Eingebaut auf localhost:9997 | Keine (Open WebUI verwenden) | Keine |
| ChatGLM-Unterstützung | Nativ (chatglm4) | Eingeschränkt | Eingeschränkt |
Ist Xinference schwieriger einzurichten als Ollama?
Etwas schwieriger. Ollama ist ein einzelner Binary-Download; Xinference erfordert Python und pip. Aber beide sind in unter 5 Minuten einsatzbereit. Xinference bietet eine reichhaltigere Multi-Modell-Umgebung nach dem Start.
Kann Xinference vLLM ersetzen?
Für Single-Machine-Serving ja — Xinference kann vLLM als Backend verwenden (`--model-engine vllm`) und fügt Web-Oberfläche und Modell-Registrierung hinzu. Für maximalen Rohdurchsatz über mehrere GPU-Knoten sind dedizierte vLLM-Deployments noch schneller.
Häufig gestellte Fragen
Was ist Xinference?
Xinference (Xorbits Inference) ist ein Open-Source-Framework für Modellbereitstellung, das Llama 3, Qwen, ChatGLM, Mistral und über 30 weitere Familien lokal über eine OpenAI-kompatible API ausführt. Es unterstützt GPU-, CPU- (via llama.cpp) und Multi-GPU-Cluster-Deployments.
Welche Modelle unterstützt Xinference 2026?
Xinference registriert über 200 Modellkonfigurationen. Die beliebtesten 2026 sind Llama 3.1 8B/70B Instruct, Qwen 2.5 7B/72B Instruct, ChatGLM4 9B, Mistral 7B Instruct v0.3 und Mixtral 8x7B Instruct. Führe `xinference registrations --model-type LLM` aus, um die vollständige Liste zu sehen.
Wie lädt Xinference Modellgewichte herunter?
Beim ersten `xinference launch` für jedes Modell lädt Xinference Gewichte von Hugging Face oder ModelScope (konfigurierbar) herunter. Gewichte werden lokal gecacht, sodass nachfolgende Starts sofort erfolgen. Setze `XINFERENCE_HOME` zur Steuerung des Cache-Verzeichnisses.
Funktioniert Xinference auf Windows?
Ja, über pip auf Python 3.9+. Das llama.cpp-Backend funktioniert auf Windows CPU ohne zusätzliche Abhängigkeiten. Für GPU-Unterstützung installiere CUDA 12.x und das entsprechende PyTorch-Wheel vor der Xinference-Installation.
Kann ich Xinference für RAG verwenden?
Ja. Starte ein BGE- oder E5-Embedding-Modell (`xinference launch --model-name bge-base-en-v1.5 --model-type embedding`) neben deinem LLM. Beide teilen denselben API-Endpunkt — deine RAG-Pipeline ruft den Embedding-Endpunkt für die Indizierung und den Chat-Endpunkt für die Generierung auf.
Muss ich bei der Verwendung von Xinference die DSGVO beachten?
Xinference verarbeitet alle Anfragen lokal — keine Daten werden an externe Dienste übertragen. Das erfüllt DSGVO Art. 32 (technische Sicherheitsmaßnahmen) und Art. 25 (Datenschutz durch Technikgestaltung). Für den Unternehmenseinsatz: Verarbeitungsverzeichnis (Art. 30) führen und bei besonders sensiblen Daten eine Datenschutz-Folgenabschätzung (Art. 35) durchführen.
Ist Xinference für den deutschen Mittelstand geeignet?
Ja, besonders gut. Mittelständische Unternehmen profitieren von vollständiger Datensouveränität, einfacher Python-Integration und Multi-Modell-Serving für verschiedene Fachabteilungen. Das BSI empfiehlt lokale KI-Systeme für kritische Verarbeitungsprozesse statt Cloud-APIs. Xinference läuft auf handelsüblicher Hardware (RTX 4070 oder besser).